Skip to main content

models

models

import "github.com/cloudfoundry/go-cf-api/internal/storage/db/models"

Index

Variables

var (
    appAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    appAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    appAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    appAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    appAnnotationType                 = reflect.TypeOf(&AppAnnotation{})
    appAnnotationMapping              = queries.MakeStructMapping(appAnnotationType)
    appAnnotationPrimaryKeyMapping, _ = queries.BindMapping(appAnnotationType, appAnnotationMapping, appAnnotationPrimaryKeyColumns)
    appAnnotationInsertCacheMut       sync.RWMutex
    appAnnotationInsertCache          = make(map[string]insertCache)
    appAnnotationUpdateCacheMut       sync.RWMutex
    appAnnotationUpdateCache          = make(map[string]updateCache)
    appAnnotationUpsertCacheMut       sync.RWMutex
    appAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    appEventAllColumns            = []string{"id", "guid", "created_at", "updated_at", "app_id", "instance_guid", "instance_index", "exit_status", "timestamp", "exit_description"}
    appEventColumnsWithoutDefault = []string{"guid", "updated_at", "app_id", "instance_guid", "instance_index", "exit_status", "timestamp", "exit_description"}
    appEventColumnsWithDefault    = []string{"id", "created_at"}
    appEventPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    appEventType                 = reflect.TypeOf(&AppEvent{})
    appEventMapping              = queries.MakeStructMapping(appEventType)
    appEventPrimaryKeyMapping, _ = queries.BindMapping(appEventType, appEventMapping, appEventPrimaryKeyColumns)
    appEventInsertCacheMut       sync.RWMutex
    appEventInsertCache          = make(map[string]insertCache)
    appEventUpdateCacheMut       sync.RWMutex
    appEventUpdateCache          = make(map[string]updateCache)
    appEventUpsertCacheMut       sync.RWMutex
    appEventUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    appLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    appLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    appLabelColumnsWithDefault    = []string{"id", "created_at"}
    appLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    appLabelType                 = reflect.TypeOf(&AppLabel{})
    appLabelMapping              = queries.MakeStructMapping(appLabelType)
    appLabelPrimaryKeyMapping, _ = queries.BindMapping(appLabelType, appLabelMapping, appLabelPrimaryKeyColumns)
    appLabelInsertCacheMut       sync.RWMutex
    appLabelInsertCache          = make(map[string]insertCache)
    appLabelUpdateCacheMut       sync.RWMutex
    appLabelUpdateCache          = make(map[string]updateCache)
    appLabelUpsertCacheMut       sync.RWMutex
    appLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    appUsageEventAllColumns            = []string{"id", "guid", "created_at", "instance_count", "memory_in_mb_per_instance", "state", "app_guid", "app_name", "space_guid", "space_name", "org_guid", "buildpack_guid", "buildpack_name", "package_state", "parent_app_name", "parent_app_guid", "process_type", "task_guid", "task_name", "package_guid", "previous_state", "previous_package_state", "previous_memory_in_mb_per_instance", "previous_instance_count"}
    appUsageEventColumnsWithoutDefault = []string{"guid", "created_at", "instance_count", "memory_in_mb_per_instance", "state", "app_guid", "app_name", "space_guid", "space_name", "org_guid", "buildpack_guid", "buildpack_name", "package_state", "parent_app_name", "parent_app_guid", "process_type", "task_guid", "task_name", "package_guid", "previous_state", "previous_package_state", "previous_memory_in_mb_per_instance", "previous_instance_count"}
    appUsageEventColumnsWithDefault    = []string{"id"}
    appUsageEventPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    appUsageEventType                 = reflect.TypeOf(&AppUsageEvent{})
    appUsageEventMapping              = queries.MakeStructMapping(appUsageEventType)
    appUsageEventPrimaryKeyMapping, _ = queries.BindMapping(appUsageEventType, appUsageEventMapping, appUsageEventPrimaryKeyColumns)
    appUsageEventInsertCacheMut       sync.RWMutex
    appUsageEventInsertCache          = make(map[string]insertCache)
    appUsageEventUpdateCacheMut       sync.RWMutex
    appUsageEventUpdateCache          = make(map[string]updateCache)
    appUsageEventUpsertCacheMut       sync.RWMutex
    appUsageEventUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    appAllColumns            = []string{"id", "guid", "created_at", "updated_at", "space_guid", "name", "droplet_guid", "desired_state", "encrypted_environment_variables", "salt", "max_task_sequence_id", "buildpack_cache_sha256_checksum", "enable_ssh", "encryption_key_label", "encryption_iterations", "revisions_enabled"}
    appColumnsWithoutDefault = []string{"guid", "updated_at", "space_guid", "name", "droplet_guid", "encrypted_environment_variables", "salt", "buildpack_cache_sha256_checksum", "enable_ssh", "encryption_key_label"}
    appColumnsWithDefault    = []string{"id", "created_at", "desired_state", "max_task_sequence_id", "encryption_iterations", "revisions_enabled"}
    appPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    appType                 = reflect.TypeOf(&App{})
    appMapping              = queries.MakeStructMapping(appType)
    appPrimaryKeyMapping, _ = queries.BindMapping(appType, appMapping, appPrimaryKeyColumns)
    appInsertCacheMut       sync.RWMutex
    appInsertCache          = make(map[string]insertCache)
    appUpdateCacheMut       sync.RWMutex
    appUpdateCache          = make(map[string]updateCache)
    appUpsertCacheMut       sync.RWMutex
    appUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    buildAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    buildAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    buildAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    buildAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    buildAnnotationType                 = reflect.TypeOf(&BuildAnnotation{})
    buildAnnotationMapping              = queries.MakeStructMapping(buildAnnotationType)
    buildAnnotationPrimaryKeyMapping, _ = queries.BindMapping(buildAnnotationType, buildAnnotationMapping, buildAnnotationPrimaryKeyColumns)
    buildAnnotationInsertCacheMut       sync.RWMutex
    buildAnnotationInsertCache          = make(map[string]insertCache)
    buildAnnotationUpdateCacheMut       sync.RWMutex
    buildAnnotationUpdateCache          = make(map[string]updateCache)
    buildAnnotationUpsertCacheMut       sync.RWMutex
    buildAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    buildLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    buildLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    buildLabelColumnsWithDefault    = []string{"id", "created_at"}
    buildLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    buildLabelType                 = reflect.TypeOf(&BuildLabel{})
    buildLabelMapping              = queries.MakeStructMapping(buildLabelType)
    buildLabelPrimaryKeyMapping, _ = queries.BindMapping(buildLabelType, buildLabelMapping, buildLabelPrimaryKeyColumns)
    buildLabelInsertCacheMut       sync.RWMutex
    buildLabelInsertCache          = make(map[string]insertCache)
    buildLabelUpdateCacheMut       sync.RWMutex
    buildLabelUpdateCache          = make(map[string]updateCache)
    buildLabelUpsertCacheMut       sync.RWMutex
    buildLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    buildpackAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    buildpackAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    buildpackAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    buildpackAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    buildpackAnnotationType                 = reflect.TypeOf(&BuildpackAnnotation{})
    buildpackAnnotationMapping              = queries.MakeStructMapping(buildpackAnnotationType)
    buildpackAnnotationPrimaryKeyMapping, _ = queries.BindMapping(buildpackAnnotationType, buildpackAnnotationMapping, buildpackAnnotationPrimaryKeyColumns)
    buildpackAnnotationInsertCacheMut       sync.RWMutex
    buildpackAnnotationInsertCache          = make(map[string]insertCache)
    buildpackAnnotationUpdateCacheMut       sync.RWMutex
    buildpackAnnotationUpdateCache          = make(map[string]updateCache)
    buildpackAnnotationUpsertCacheMut       sync.RWMutex
    buildpackAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    buildpackLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    buildpackLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    buildpackLabelColumnsWithDefault    = []string{"id", "created_at"}
    buildpackLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    buildpackLabelType                 = reflect.TypeOf(&BuildpackLabel{})
    buildpackLabelMapping              = queries.MakeStructMapping(buildpackLabelType)
    buildpackLabelPrimaryKeyMapping, _ = queries.BindMapping(buildpackLabelType, buildpackLabelMapping, buildpackLabelPrimaryKeyColumns)
    buildpackLabelInsertCacheMut       sync.RWMutex
    buildpackLabelInsertCache          = make(map[string]insertCache)
    buildpackLabelUpdateCacheMut       sync.RWMutex
    buildpackLabelUpdateCache          = make(map[string]updateCache)
    buildpackLabelUpsertCacheMut       sync.RWMutex
    buildpackLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    buildpackLifecycleBuildpackAllColumns            = []string{"id", "guid", "created_at", "updated_at", "admin_buildpack_name", "encrypted_buildpack_url", "encrypted_buildpack_url_salt", "buildpack_lifecycle_data_guid", "encryption_key_label", "version", "buildpack_name", "encryption_iterations"}
    buildpackLifecycleBuildpackColumnsWithoutDefault = []string{"guid", "updated_at", "admin_buildpack_name", "encrypted_buildpack_url", "encrypted_buildpack_url_salt", "buildpack_lifecycle_data_guid", "encryption_key_label", "version", "buildpack_name"}
    buildpackLifecycleBuildpackColumnsWithDefault    = []string{"id", "created_at", "encryption_iterations"}
    buildpackLifecycleBuildpackPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    buildpackLifecycleBuildpackType                 = reflect.TypeOf(&BuildpackLifecycleBuildpack{})
    buildpackLifecycleBuildpackMapping              = queries.MakeStructMapping(buildpackLifecycleBuildpackType)
    buildpackLifecycleBuildpackPrimaryKeyMapping, _ = queries.BindMapping(buildpackLifecycleBuildpackType, buildpackLifecycleBuildpackMapping, buildpackLifecycleBuildpackPrimaryKeyColumns)
    buildpackLifecycleBuildpackInsertCacheMut       sync.RWMutex
    buildpackLifecycleBuildpackInsertCache          = make(map[string]insertCache)
    buildpackLifecycleBuildpackUpdateCacheMut       sync.RWMutex
    buildpackLifecycleBuildpackUpdateCache          = make(map[string]updateCache)
    buildpackLifecycleBuildpackUpsertCacheMut       sync.RWMutex
    buildpackLifecycleBuildpackUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    buildpackLifecycleDatumAllColumns            = []string{"id", "guid", "created_at", "updated_at", "app_guid", "droplet_guid", "stack", "encrypted_buildpack_url", "encrypted_buildpack_url_salt", "admin_buildpack_name", "build_guid", "encryption_key_label", "encryption_iterations"}
    buildpackLifecycleDatumColumnsWithoutDefault = []string{"guid", "updated_at", "app_guid", "droplet_guid", "stack", "encrypted_buildpack_url", "encrypted_buildpack_url_salt", "admin_buildpack_name", "build_guid", "encryption_key_label"}
    buildpackLifecycleDatumColumnsWithDefault    = []string{"id", "created_at", "encryption_iterations"}
    buildpackLifecycleDatumPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    buildpackLifecycleDatumType                 = reflect.TypeOf(&BuildpackLifecycleDatum{})
    buildpackLifecycleDatumMapping              = queries.MakeStructMapping(buildpackLifecycleDatumType)
    buildpackLifecycleDatumPrimaryKeyMapping, _ = queries.BindMapping(buildpackLifecycleDatumType, buildpackLifecycleDatumMapping, buildpackLifecycleDatumPrimaryKeyColumns)
    buildpackLifecycleDatumInsertCacheMut       sync.RWMutex
    buildpackLifecycleDatumInsertCache          = make(map[string]insertCache)
    buildpackLifecycleDatumUpdateCacheMut       sync.RWMutex
    buildpackLifecycleDatumUpdateCache          = make(map[string]updateCache)
    buildpackLifecycleDatumUpsertCacheMut       sync.RWMutex
    buildpackLifecycleDatumUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    buildpackAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "key", "position", "enabled", "locked", "filename", "sha256_checksum", "stack"}
    buildpackColumnsWithoutDefault = []string{"guid", "updated_at", "name", "key", "position", "filename", "sha256_checksum", "stack"}
    buildpackColumnsWithDefault    = []string{"id", "created_at", "enabled", "locked"}
    buildpackPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    buildpackType                 = reflect.TypeOf(&Buildpack{})
    buildpackMapping              = queries.MakeStructMapping(buildpackType)
    buildpackPrimaryKeyMapping, _ = queries.BindMapping(buildpackType, buildpackMapping, buildpackPrimaryKeyColumns)
    buildpackInsertCacheMut       sync.RWMutex
    buildpackInsertCache          = make(map[string]insertCache)
    buildpackUpdateCacheMut       sync.RWMutex
    buildpackUpdateCache          = make(map[string]updateCache)
    buildpackUpsertCacheMut       sync.RWMutex
    buildpackUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    buildAllColumns            = []string{"id", "guid", "created_at", "updated_at", "state", "package_guid", "error_description", "app_guid", "error_id", "created_by_user_guid", "created_by_user_name", "created_by_user_email", "staging_memory_in_mb", "staging_disk_in_mb"}
    buildColumnsWithoutDefault = []string{"guid", "updated_at", "state", "package_guid", "error_description", "app_guid", "error_id", "created_by_user_guid", "created_by_user_name", "created_by_user_email", "staging_memory_in_mb", "staging_disk_in_mb"}
    buildColumnsWithDefault    = []string{"id", "created_at"}
    buildPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    buildType                 = reflect.TypeOf(&Build{})
    buildMapping              = queries.MakeStructMapping(buildType)
    buildPrimaryKeyMapping, _ = queries.BindMapping(buildType, buildMapping, buildPrimaryKeyColumns)
    buildInsertCacheMut       sync.RWMutex
    buildInsertCache          = make(map[string]insertCache)
    buildUpdateCacheMut       sync.RWMutex
    buildUpdateCache          = make(map[string]updateCache)
    buildUpsertCacheMut       sync.RWMutex
    buildUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    clockJobAllColumns            = []string{"id", "name", "last_started_at", "last_completed_at"}
    clockJobColumnsWithoutDefault = []string{"name", "last_started_at", "last_completed_at"}
    clockJobColumnsWithDefault    = []string{"id"}
    clockJobPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    clockJobType                 = reflect.TypeOf(&ClockJob{})
    clockJobMapping              = queries.MakeStructMapping(clockJobType)
    clockJobPrimaryKeyMapping, _ = queries.BindMapping(clockJobType, clockJobMapping, clockJobPrimaryKeyColumns)
    clockJobInsertCacheMut       sync.RWMutex
    clockJobInsertCache          = make(map[string]insertCache)
    clockJobUpdateCacheMut       sync.RWMutex
    clockJobUpdateCache          = make(map[string]updateCache)
    clockJobUpsertCacheMut       sync.RWMutex
    clockJobUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    delayedJobAllColumns            = []string{"id", "guid", "created_at", "updated_at", "priority", "attempts", "handler", "last_error", "run_at", "locked_at", "failed_at", "locked_by", "queue", "cf_api_error"}
    delayedJobColumnsWithoutDefault = []string{"guid", "updated_at", "handler", "last_error", "run_at", "locked_at", "failed_at", "locked_by", "queue", "cf_api_error"}
    delayedJobColumnsWithDefault    = []string{"id", "created_at", "priority", "attempts"}
    delayedJobPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    delayedJobType                 = reflect.TypeOf(&DelayedJob{})
    delayedJobMapping              = queries.MakeStructMapping(delayedJobType)
    delayedJobPrimaryKeyMapping, _ = queries.BindMapping(delayedJobType, delayedJobMapping, delayedJobPrimaryKeyColumns)
    delayedJobInsertCacheMut       sync.RWMutex
    delayedJobInsertCache          = make(map[string]insertCache)
    delayedJobUpdateCacheMut       sync.RWMutex
    delayedJobUpdateCache          = make(map[string]updateCache)
    delayedJobUpsertCacheMut       sync.RWMutex
    delayedJobUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    deploymentAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    deploymentAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    deploymentAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    deploymentAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    deploymentAnnotationType                 = reflect.TypeOf(&DeploymentAnnotation{})
    deploymentAnnotationMapping              = queries.MakeStructMapping(deploymentAnnotationType)
    deploymentAnnotationPrimaryKeyMapping, _ = queries.BindMapping(deploymentAnnotationType, deploymentAnnotationMapping, deploymentAnnotationPrimaryKeyColumns)
    deploymentAnnotationInsertCacheMut       sync.RWMutex
    deploymentAnnotationInsertCache          = make(map[string]insertCache)
    deploymentAnnotationUpdateCacheMut       sync.RWMutex
    deploymentAnnotationUpdateCache          = make(map[string]updateCache)
    deploymentAnnotationUpsertCacheMut       sync.RWMutex
    deploymentAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    deploymentLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    deploymentLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    deploymentLabelColumnsWithDefault    = []string{"id", "created_at"}
    deploymentLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    deploymentLabelType                 = reflect.TypeOf(&DeploymentLabel{})
    deploymentLabelMapping              = queries.MakeStructMapping(deploymentLabelType)
    deploymentLabelPrimaryKeyMapping, _ = queries.BindMapping(deploymentLabelType, deploymentLabelMapping, deploymentLabelPrimaryKeyColumns)
    deploymentLabelInsertCacheMut       sync.RWMutex
    deploymentLabelInsertCache          = make(map[string]insertCache)
    deploymentLabelUpdateCacheMut       sync.RWMutex
    deploymentLabelUpdateCache          = make(map[string]updateCache)
    deploymentLabelUpsertCacheMut       sync.RWMutex
    deploymentLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    deploymentProcessAllColumns            = []string{"id", "guid", "created_at", "updated_at", "process_guid", "process_type", "deployment_guid"}
    deploymentProcessColumnsWithoutDefault = []string{"guid", "updated_at", "process_guid", "process_type", "deployment_guid"}
    deploymentProcessColumnsWithDefault    = []string{"id", "created_at"}
    deploymentProcessPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    deploymentProcessType                 = reflect.TypeOf(&DeploymentProcess{})
    deploymentProcessMapping              = queries.MakeStructMapping(deploymentProcessType)
    deploymentProcessPrimaryKeyMapping, _ = queries.BindMapping(deploymentProcessType, deploymentProcessMapping, deploymentProcessPrimaryKeyColumns)
    deploymentProcessInsertCacheMut       sync.RWMutex
    deploymentProcessInsertCache          = make(map[string]insertCache)
    deploymentProcessUpdateCacheMut       sync.RWMutex
    deploymentProcessUpdateCache          = make(map[string]updateCache)
    deploymentProcessUpsertCacheMut       sync.RWMutex
    deploymentProcessUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    deploymentAllColumns            = []string{"id", "guid", "created_at", "updated_at", "state", "app_guid", "droplet_guid", "deploying_web_process_guid", "previous_droplet_guid", "original_web_process_instance_count", "revision_guid", "revision_version", "last_healthy_at", "status_value", "status_reason", "strategy"}
    deploymentColumnsWithoutDefault = []string{"guid", "updated_at", "state", "app_guid", "droplet_guid", "deploying_web_process_guid", "previous_droplet_guid", "original_web_process_instance_count", "revision_guid", "revision_version", "status_value", "status_reason"}
    deploymentColumnsWithDefault    = []string{"id", "created_at", "last_healthy_at", "strategy"}
    deploymentPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    deploymentType                 = reflect.TypeOf(&Deployment{})
    deploymentMapping              = queries.MakeStructMapping(deploymentType)
    deploymentPrimaryKeyMapping, _ = queries.BindMapping(deploymentType, deploymentMapping, deploymentPrimaryKeyColumns)
    deploymentInsertCacheMut       sync.RWMutex
    deploymentInsertCache          = make(map[string]insertCache)
    deploymentUpdateCacheMut       sync.RWMutex
    deploymentUpdateCache          = make(map[string]updateCache)
    deploymentUpsertCacheMut       sync.RWMutex
    deploymentUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    domainAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    domainAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    domainAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    domainAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    domainAnnotationType                 = reflect.TypeOf(&DomainAnnotation{})
    domainAnnotationMapping              = queries.MakeStructMapping(domainAnnotationType)
    domainAnnotationPrimaryKeyMapping, _ = queries.BindMapping(domainAnnotationType, domainAnnotationMapping, domainAnnotationPrimaryKeyColumns)
    domainAnnotationInsertCacheMut       sync.RWMutex
    domainAnnotationInsertCache          = make(map[string]insertCache)
    domainAnnotationUpdateCacheMut       sync.RWMutex
    domainAnnotationUpdateCache          = make(map[string]updateCache)
    domainAnnotationUpsertCacheMut       sync.RWMutex
    domainAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    domainLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    domainLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    domainLabelColumnsWithDefault    = []string{"id", "created_at"}
    domainLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    domainLabelType                 = reflect.TypeOf(&DomainLabel{})
    domainLabelMapping              = queries.MakeStructMapping(domainLabelType)
    domainLabelPrimaryKeyMapping, _ = queries.BindMapping(domainLabelType, domainLabelMapping, domainLabelPrimaryKeyColumns)
    domainLabelInsertCacheMut       sync.RWMutex
    domainLabelInsertCache          = make(map[string]insertCache)
    domainLabelUpdateCacheMut       sync.RWMutex
    domainLabelUpdateCache          = make(map[string]updateCache)
    domainLabelUpsertCacheMut       sync.RWMutex
    domainLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    domainAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "wildcard", "owning_organization_id", "router_group_guid", "internal"}
    domainColumnsWithoutDefault = []string{"guid", "updated_at", "name", "owning_organization_id", "router_group_guid"}
    domainColumnsWithDefault    = []string{"id", "created_at", "wildcard", "internal"}
    domainPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    domainType                 = reflect.TypeOf(&Domain{})
    domainMapping              = queries.MakeStructMapping(domainType)
    domainPrimaryKeyMapping, _ = queries.BindMapping(domainType, domainMapping, domainPrimaryKeyColumns)
    domainInsertCacheMut       sync.RWMutex
    domainInsertCache          = make(map[string]insertCache)
    domainUpdateCacheMut       sync.RWMutex
    domainUpdateCache          = make(map[string]updateCache)
    domainUpsertCacheMut       sync.RWMutex
    domainUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    dropletAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    dropletAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    dropletAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    dropletAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    dropletAnnotationType                 = reflect.TypeOf(&DropletAnnotation{})
    dropletAnnotationMapping              = queries.MakeStructMapping(dropletAnnotationType)
    dropletAnnotationPrimaryKeyMapping, _ = queries.BindMapping(dropletAnnotationType, dropletAnnotationMapping, dropletAnnotationPrimaryKeyColumns)
    dropletAnnotationInsertCacheMut       sync.RWMutex
    dropletAnnotationInsertCache          = make(map[string]insertCache)
    dropletAnnotationUpdateCacheMut       sync.RWMutex
    dropletAnnotationUpdateCache          = make(map[string]updateCache)
    dropletAnnotationUpsertCacheMut       sync.RWMutex
    dropletAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    dropletLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    dropletLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    dropletLabelColumnsWithDefault    = []string{"id", "created_at"}
    dropletLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    dropletLabelType                 = reflect.TypeOf(&DropletLabel{})
    dropletLabelMapping              = queries.MakeStructMapping(dropletLabelType)
    dropletLabelPrimaryKeyMapping, _ = queries.BindMapping(dropletLabelType, dropletLabelMapping, dropletLabelPrimaryKeyColumns)
    dropletLabelInsertCacheMut       sync.RWMutex
    dropletLabelInsertCache          = make(map[string]insertCache)
    dropletLabelUpdateCacheMut       sync.RWMutex
    dropletLabelUpdateCache          = make(map[string]updateCache)
    dropletLabelUpsertCacheMut       sync.RWMutex
    dropletLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    dropletAllColumns            = []string{"id", "guid", "created_at", "updated_at", "droplet_hash", "execution_metadata", "state", "process_types", "error_id", "error_description", "encrypted_environment_variables", "salt", "staging_memory_in_mb", "staging_disk_in_mb", "buildpack_receipt_buildpack", "buildpack_receipt_buildpack_guid", "buildpack_receipt_detect_output", "docker_receipt_image", "package_guid", "app_guid", "sha256_checksum", "build_guid", "docker_receipt_username", "docker_receipt_password_salt", "encrypted_docker_receipt_password", "encryption_key_label", "encryption_iterations", "sidecars"}
    dropletColumnsWithoutDefault = []string{"guid", "updated_at", "droplet_hash", "execution_metadata", "state", "process_types", "error_id", "error_description", "encrypted_environment_variables", "salt", "staging_memory_in_mb", "staging_disk_in_mb", "buildpack_receipt_buildpack", "buildpack_receipt_buildpack_guid", "buildpack_receipt_detect_output", "docker_receipt_image", "package_guid", "app_guid", "sha256_checksum", "build_guid", "docker_receipt_username", "docker_receipt_password_salt", "encrypted_docker_receipt_password", "encryption_key_label", "sidecars"}
    dropletColumnsWithDefault    = []string{"id", "created_at", "encryption_iterations"}
    dropletPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    dropletType                 = reflect.TypeOf(&Droplet{})
    dropletMapping              = queries.MakeStructMapping(dropletType)
    dropletPrimaryKeyMapping, _ = queries.BindMapping(dropletType, dropletMapping, dropletPrimaryKeyColumns)
    dropletInsertCacheMut       sync.RWMutex
    dropletInsertCache          = make(map[string]insertCache)
    dropletUpdateCacheMut       sync.RWMutex
    dropletUpdateCache          = make(map[string]updateCache)
    dropletUpsertCacheMut       sync.RWMutex
    dropletUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    encryptionKeySentinelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "expected_value", "encrypted_value", "encryption_key_label", "salt", "encryption_iterations"}
    encryptionKeySentinelColumnsWithoutDefault = []string{"guid", "updated_at", "expected_value", "encrypted_value", "encryption_key_label", "salt"}
    encryptionKeySentinelColumnsWithDefault    = []string{"id", "created_at", "encryption_iterations"}
    encryptionKeySentinelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    encryptionKeySentinelType                 = reflect.TypeOf(&EncryptionKeySentinel{})
    encryptionKeySentinelMapping              = queries.MakeStructMapping(encryptionKeySentinelType)
    encryptionKeySentinelPrimaryKeyMapping, _ = queries.BindMapping(encryptionKeySentinelType, encryptionKeySentinelMapping, encryptionKeySentinelPrimaryKeyColumns)
    encryptionKeySentinelInsertCacheMut       sync.RWMutex
    encryptionKeySentinelInsertCache          = make(map[string]insertCache)
    encryptionKeySentinelUpdateCacheMut       sync.RWMutex
    encryptionKeySentinelUpdateCache          = make(map[string]updateCache)
    encryptionKeySentinelUpsertCacheMut       sync.RWMutex
    encryptionKeySentinelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    envGroupAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "environment_json", "salt", "encryption_key_label", "encryption_iterations"}
    envGroupColumnsWithoutDefault = []string{"guid", "updated_at", "name", "environment_json", "salt", "encryption_key_label"}
    envGroupColumnsWithDefault    = []string{"id", "created_at", "encryption_iterations"}
    envGroupPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    envGroupType                 = reflect.TypeOf(&EnvGroup{})
    envGroupMapping              = queries.MakeStructMapping(envGroupType)
    envGroupPrimaryKeyMapping, _ = queries.BindMapping(envGroupType, envGroupMapping, envGroupPrimaryKeyColumns)
    envGroupInsertCacheMut       sync.RWMutex
    envGroupInsertCache          = make(map[string]insertCache)
    envGroupUpdateCacheMut       sync.RWMutex
    envGroupUpdateCache          = make(map[string]updateCache)
    envGroupUpsertCacheMut       sync.RWMutex
    envGroupUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    eventAllColumns            = []string{"id", "guid", "created_at", "updated_at", "timestamp", "type", "actor", "actor_type", "actee", "actee_type", "metadata", "organization_guid", "space_guid", "actor_name", "actee_name", "actor_username"}
    eventColumnsWithoutDefault = []string{"guid", "updated_at", "timestamp", "type", "actor", "actor_type", "actee", "actee_type", "metadata", "actor_name", "actee_name", "actor_username"}
    eventColumnsWithDefault    = []string{"id", "created_at", "organization_guid", "space_guid"}
    eventPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    eventType                 = reflect.TypeOf(&Event{})
    eventMapping              = queries.MakeStructMapping(eventType)
    eventPrimaryKeyMapping, _ = queries.BindMapping(eventType, eventMapping, eventPrimaryKeyColumns)
    eventInsertCacheMut       sync.RWMutex
    eventInsertCache          = make(map[string]insertCache)
    eventUpdateCacheMut       sync.RWMutex
    eventUpdateCache          = make(map[string]updateCache)
    eventUpsertCacheMut       sync.RWMutex
    eventUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    featureFlagAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "enabled", "error_message"}
    featureFlagColumnsWithoutDefault = []string{"guid", "updated_at", "name", "enabled", "error_message"}
    featureFlagColumnsWithDefault    = []string{"id", "created_at"}
    featureFlagPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    featureFlagType                 = reflect.TypeOf(&FeatureFlag{})
    featureFlagMapping              = queries.MakeStructMapping(featureFlagType)
    featureFlagPrimaryKeyMapping, _ = queries.BindMapping(featureFlagType, featureFlagMapping, featureFlagPrimaryKeyColumns)
    featureFlagInsertCacheMut       sync.RWMutex
    featureFlagInsertCache          = make(map[string]insertCache)
    featureFlagUpdateCacheMut       sync.RWMutex
    featureFlagUpdateCache          = make(map[string]updateCache)
    featureFlagUpsertCacheMut       sync.RWMutex
    featureFlagUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    isolationSegmentAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    isolationSegmentAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    isolationSegmentAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    isolationSegmentAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    isolationSegmentAnnotationType                 = reflect.TypeOf(&IsolationSegmentAnnotation{})
    isolationSegmentAnnotationMapping              = queries.MakeStructMapping(isolationSegmentAnnotationType)
    isolationSegmentAnnotationPrimaryKeyMapping, _ = queries.BindMapping(isolationSegmentAnnotationType, isolationSegmentAnnotationMapping, isolationSegmentAnnotationPrimaryKeyColumns)
    isolationSegmentAnnotationInsertCacheMut       sync.RWMutex
    isolationSegmentAnnotationInsertCache          = make(map[string]insertCache)
    isolationSegmentAnnotationUpdateCacheMut       sync.RWMutex
    isolationSegmentAnnotationUpdateCache          = make(map[string]updateCache)
    isolationSegmentAnnotationUpsertCacheMut       sync.RWMutex
    isolationSegmentAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    isolationSegmentLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    isolationSegmentLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    isolationSegmentLabelColumnsWithDefault    = []string{"id", "created_at"}
    isolationSegmentLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    isolationSegmentLabelType                 = reflect.TypeOf(&IsolationSegmentLabel{})
    isolationSegmentLabelMapping              = queries.MakeStructMapping(isolationSegmentLabelType)
    isolationSegmentLabelPrimaryKeyMapping, _ = queries.BindMapping(isolationSegmentLabelType, isolationSegmentLabelMapping, isolationSegmentLabelPrimaryKeyColumns)
    isolationSegmentLabelInsertCacheMut       sync.RWMutex
    isolationSegmentLabelInsertCache          = make(map[string]insertCache)
    isolationSegmentLabelUpdateCacheMut       sync.RWMutex
    isolationSegmentLabelUpdateCache          = make(map[string]updateCache)
    isolationSegmentLabelUpsertCacheMut       sync.RWMutex
    isolationSegmentLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    isolationSegmentAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name"}
    isolationSegmentColumnsWithoutDefault = []string{"guid", "updated_at", "name"}
    isolationSegmentColumnsWithDefault    = []string{"id", "created_at"}
    isolationSegmentPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    isolationSegmentType                 = reflect.TypeOf(&IsolationSegment{})
    isolationSegmentMapping              = queries.MakeStructMapping(isolationSegmentType)
    isolationSegmentPrimaryKeyMapping, _ = queries.BindMapping(isolationSegmentType, isolationSegmentMapping, isolationSegmentPrimaryKeyColumns)
    isolationSegmentInsertCacheMut       sync.RWMutex
    isolationSegmentInsertCache          = make(map[string]insertCache)
    isolationSegmentUpdateCacheMut       sync.RWMutex
    isolationSegmentUpdateCache          = make(map[string]updateCache)
    isolationSegmentUpsertCacheMut       sync.RWMutex
    isolationSegmentUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    jobWarningAllColumns            = []string{"id", "guid", "created_at", "updated_at", "detail", "job_id", "fk_jobs_id"}
    jobWarningColumnsWithoutDefault = []string{"guid", "updated_at", "detail", "job_id", "fk_jobs_id"}
    jobWarningColumnsWithDefault    = []string{"id", "created_at"}
    jobWarningPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    jobWarningType                 = reflect.TypeOf(&JobWarning{})
    jobWarningMapping              = queries.MakeStructMapping(jobWarningType)
    jobWarningPrimaryKeyMapping, _ = queries.BindMapping(jobWarningType, jobWarningMapping, jobWarningPrimaryKeyColumns)
    jobWarningInsertCacheMut       sync.RWMutex
    jobWarningInsertCache          = make(map[string]insertCache)
    jobWarningUpdateCacheMut       sync.RWMutex
    jobWarningUpdateCache          = make(map[string]updateCache)
    jobWarningUpsertCacheMut       sync.RWMutex
    jobWarningUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    jobAllColumns            = []string{"id", "guid", "created_at", "updated_at", "state", "operation", "resource_guid", "resource_type", "delayed_job_guid", "cf_api_error"}
    jobColumnsWithoutDefault = []string{"guid", "updated_at", "state", "operation", "resource_guid", "resource_type", "delayed_job_guid", "cf_api_error"}
    jobColumnsWithDefault    = []string{"id", "created_at"}
    jobPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    jobType                 = reflect.TypeOf(&Job{})
    jobMapping              = queries.MakeStructMapping(jobType)
    jobPrimaryKeyMapping, _ = queries.BindMapping(jobType, jobMapping, jobPrimaryKeyColumns)
    jobInsertCacheMut       sync.RWMutex
    jobInsertCache          = make(map[string]insertCache)
    jobUpdateCacheMut       sync.RWMutex
    jobUpdateCache          = make(map[string]updateCache)
    jobUpsertCacheMut       sync.RWMutex
    jobUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    kpackLifecycleDatumAllColumns            = []string{"id", "guid", "created_at", "updated_at", "build_guid", "droplet_guid", "app_guid", "buildpacks"}
    kpackLifecycleDatumColumnsWithoutDefault = []string{"guid", "updated_at", "build_guid", "droplet_guid", "app_guid"}
    kpackLifecycleDatumColumnsWithDefault    = []string{"id", "created_at", "buildpacks"}
    kpackLifecycleDatumPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    kpackLifecycleDatumType                 = reflect.TypeOf(&KpackLifecycleDatum{})
    kpackLifecycleDatumMapping              = queries.MakeStructMapping(kpackLifecycleDatumType)
    kpackLifecycleDatumPrimaryKeyMapping, _ = queries.BindMapping(kpackLifecycleDatumType, kpackLifecycleDatumMapping, kpackLifecycleDatumPrimaryKeyColumns)
    kpackLifecycleDatumInsertCacheMut       sync.RWMutex
    kpackLifecycleDatumInsertCache          = make(map[string]insertCache)
    kpackLifecycleDatumUpdateCacheMut       sync.RWMutex
    kpackLifecycleDatumUpdateCache          = make(map[string]updateCache)
    kpackLifecycleDatumUpsertCacheMut       sync.RWMutex
    kpackLifecycleDatumUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    lockingAllColumns            = []string{"id", "name"}
    lockingColumnsWithoutDefault = []string{"name"}
    lockingColumnsWithDefault    = []string{"id"}
    lockingPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    lockingType                 = reflect.TypeOf(&Locking{})
    lockingMapping              = queries.MakeStructMapping(lockingType)
    lockingPrimaryKeyMapping, _ = queries.BindMapping(lockingType, lockingMapping, lockingPrimaryKeyColumns)
    lockingInsertCacheMut       sync.RWMutex
    lockingInsertCache          = make(map[string]insertCache)
    lockingUpdateCacheMut       sync.RWMutex
    lockingUpdateCache          = make(map[string]updateCache)
    lockingUpsertCacheMut       sync.RWMutex
    lockingUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    organizationAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    organizationAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    organizationAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    organizationAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    organizationAnnotationType                 = reflect.TypeOf(&OrganizationAnnotation{})
    organizationAnnotationMapping              = queries.MakeStructMapping(organizationAnnotationType)
    organizationAnnotationPrimaryKeyMapping, _ = queries.BindMapping(organizationAnnotationType, organizationAnnotationMapping, organizationAnnotationPrimaryKeyColumns)
    organizationAnnotationInsertCacheMut       sync.RWMutex
    organizationAnnotationInsertCache          = make(map[string]insertCache)
    organizationAnnotationUpdateCacheMut       sync.RWMutex
    organizationAnnotationUpdateCache          = make(map[string]updateCache)
    organizationAnnotationUpsertCacheMut       sync.RWMutex
    organizationAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    organizationLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    organizationLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    organizationLabelColumnsWithDefault    = []string{"id", "created_at"}
    organizationLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    organizationLabelType                 = reflect.TypeOf(&OrganizationLabel{})
    organizationLabelMapping              = queries.MakeStructMapping(organizationLabelType)
    organizationLabelPrimaryKeyMapping, _ = queries.BindMapping(organizationLabelType, organizationLabelMapping, organizationLabelPrimaryKeyColumns)
    organizationLabelInsertCacheMut       sync.RWMutex
    organizationLabelInsertCache          = make(map[string]insertCache)
    organizationLabelUpdateCacheMut       sync.RWMutex
    organizationLabelUpdateCache          = make(map[string]updateCache)
    organizationLabelUpsertCacheMut       sync.RWMutex
    organizationLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    organizationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "billing_enabled", "quota_definition_id", "status", "default_isolation_segment_guid"}
    organizationColumnsWithoutDefault = []string{"guid", "updated_at", "name", "quota_definition_id", "default_isolation_segment_guid"}
    organizationColumnsWithDefault    = []string{"id", "created_at", "billing_enabled", "status"}
    organizationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    organizationType                 = reflect.TypeOf(&Organization{})
    organizationMapping              = queries.MakeStructMapping(organizationType)
    organizationPrimaryKeyMapping, _ = queries.BindMapping(organizationType, organizationMapping, organizationPrimaryKeyColumns)
    organizationInsertCacheMut       sync.RWMutex
    organizationInsertCache          = make(map[string]insertCache)
    organizationUpdateCacheMut       sync.RWMutex
    organizationUpdateCache          = make(map[string]updateCache)
    organizationUpsertCacheMut       sync.RWMutex
    organizationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    organizationsAuditorAllColumns            = []string{"organization_id", "user_id", "organizations_auditors_pk", "role_guid", "created_at", "updated_at"}
    organizationsAuditorColumnsWithoutDefault = []string{"organization_id", "user_id", "role_guid"}
    organizationsAuditorColumnsWithDefault    = []string{"organizations_auditors_pk", "created_at", "updated_at"}
    organizationsAuditorPrimaryKeyColumns     = []string{"organizations_auditors_pk"}
)

Cache for insert\, update and upsert

var (
    organizationsAuditorType                 = reflect.TypeOf(&OrganizationsAuditor{})
    organizationsAuditorMapping              = queries.MakeStructMapping(organizationsAuditorType)
    organizationsAuditorPrimaryKeyMapping, _ = queries.BindMapping(organizationsAuditorType, organizationsAuditorMapping, organizationsAuditorPrimaryKeyColumns)
    organizationsAuditorInsertCacheMut       sync.RWMutex
    organizationsAuditorInsertCache          = make(map[string]insertCache)
    organizationsAuditorUpdateCacheMut       sync.RWMutex
    organizationsAuditorUpdateCache          = make(map[string]updateCache)
    organizationsAuditorUpsertCacheMut       sync.RWMutex
    organizationsAuditorUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    organizationsBillingManagerAllColumns            = []string{"organization_id", "user_id", "organizations_billing_managers_pk", "role_guid", "created_at", "updated_at"}
    organizationsBillingManagerColumnsWithoutDefault = []string{"organization_id", "user_id", "role_guid"}
    organizationsBillingManagerColumnsWithDefault    = []string{"organizations_billing_managers_pk", "created_at", "updated_at"}
    organizationsBillingManagerPrimaryKeyColumns     = []string{"organizations_billing_managers_pk"}
)

Cache for insert\, update and upsert

var (
    organizationsBillingManagerType                 = reflect.TypeOf(&OrganizationsBillingManager{})
    organizationsBillingManagerMapping              = queries.MakeStructMapping(organizationsBillingManagerType)
    organizationsBillingManagerPrimaryKeyMapping, _ = queries.BindMapping(organizationsBillingManagerType, organizationsBillingManagerMapping, organizationsBillingManagerPrimaryKeyColumns)
    organizationsBillingManagerInsertCacheMut       sync.RWMutex
    organizationsBillingManagerInsertCache          = make(map[string]insertCache)
    organizationsBillingManagerUpdateCacheMut       sync.RWMutex
    organizationsBillingManagerUpdateCache          = make(map[string]updateCache)
    organizationsBillingManagerUpsertCacheMut       sync.RWMutex
    organizationsBillingManagerUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    organizationsManagerAllColumns            = []string{"organization_id", "user_id", "organizations_managers_pk", "role_guid", "created_at", "updated_at"}
    organizationsManagerColumnsWithoutDefault = []string{"organization_id", "user_id", "role_guid"}
    organizationsManagerColumnsWithDefault    = []string{"organizations_managers_pk", "created_at", "updated_at"}
    organizationsManagerPrimaryKeyColumns     = []string{"organizations_managers_pk"}
)

Cache for insert\, update and upsert

var (
    organizationsManagerType                 = reflect.TypeOf(&OrganizationsManager{})
    organizationsManagerMapping              = queries.MakeStructMapping(organizationsManagerType)
    organizationsManagerPrimaryKeyMapping, _ = queries.BindMapping(organizationsManagerType, organizationsManagerMapping, organizationsManagerPrimaryKeyColumns)
    organizationsManagerInsertCacheMut       sync.RWMutex
    organizationsManagerInsertCache          = make(map[string]insertCache)
    organizationsManagerUpdateCacheMut       sync.RWMutex
    organizationsManagerUpdateCache          = make(map[string]updateCache)
    organizationsManagerUpsertCacheMut       sync.RWMutex
    organizationsManagerUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    organizationsPrivateDomainAllColumns            = []string{"organization_id", "private_domain_id", "organizations_private_domains_pk"}
    organizationsPrivateDomainColumnsWithoutDefault = []string{"organization_id", "private_domain_id"}
    organizationsPrivateDomainColumnsWithDefault    = []string{"organizations_private_domains_pk"}
    organizationsPrivateDomainPrimaryKeyColumns     = []string{"organizations_private_domains_pk"}
)

Cache for insert\, update and upsert

var (
    organizationsPrivateDomainType                 = reflect.TypeOf(&OrganizationsPrivateDomain{})
    organizationsPrivateDomainMapping              = queries.MakeStructMapping(organizationsPrivateDomainType)
    organizationsPrivateDomainPrimaryKeyMapping, _ = queries.BindMapping(organizationsPrivateDomainType, organizationsPrivateDomainMapping, organizationsPrivateDomainPrimaryKeyColumns)
    organizationsPrivateDomainInsertCacheMut       sync.RWMutex
    organizationsPrivateDomainInsertCache          = make(map[string]insertCache)
    organizationsPrivateDomainUpdateCacheMut       sync.RWMutex
    organizationsPrivateDomainUpdateCache          = make(map[string]updateCache)
    organizationsPrivateDomainUpsertCacheMut       sync.RWMutex
    organizationsPrivateDomainUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    organizationsUserAllColumns            = []string{"organization_id", "user_id", "organizations_users_pk", "role_guid", "created_at", "updated_at"}
    organizationsUserColumnsWithoutDefault = []string{"organization_id", "user_id", "role_guid"}
    organizationsUserColumnsWithDefault    = []string{"organizations_users_pk", "created_at", "updated_at"}
    organizationsUserPrimaryKeyColumns     = []string{"organizations_users_pk"}
)

Cache for insert\, update and upsert

var (
    organizationsUserType                 = reflect.TypeOf(&OrganizationsUser{})
    organizationsUserMapping              = queries.MakeStructMapping(organizationsUserType)
    organizationsUserPrimaryKeyMapping, _ = queries.BindMapping(organizationsUserType, organizationsUserMapping, organizationsUserPrimaryKeyColumns)
    organizationsUserInsertCacheMut       sync.RWMutex
    organizationsUserInsertCache          = make(map[string]insertCache)
    organizationsUserUpdateCacheMut       sync.RWMutex
    organizationsUserUpdateCache          = make(map[string]updateCache)
    organizationsUserUpsertCacheMut       sync.RWMutex
    organizationsUserUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    orphanedBlobAllColumns            = []string{"id", "guid", "created_at", "updated_at", "blob_key", "dirty_count", "blobstore_type"}
    orphanedBlobColumnsWithoutDefault = []string{"guid", "updated_at", "blob_key", "dirty_count", "blobstore_type"}
    orphanedBlobColumnsWithDefault    = []string{"id", "created_at"}
    orphanedBlobPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    orphanedBlobType                 = reflect.TypeOf(&OrphanedBlob{})
    orphanedBlobMapping              = queries.MakeStructMapping(orphanedBlobType)
    orphanedBlobPrimaryKeyMapping, _ = queries.BindMapping(orphanedBlobType, orphanedBlobMapping, orphanedBlobPrimaryKeyColumns)
    orphanedBlobInsertCacheMut       sync.RWMutex
    orphanedBlobInsertCache          = make(map[string]insertCache)
    orphanedBlobUpdateCacheMut       sync.RWMutex
    orphanedBlobUpdateCache          = make(map[string]updateCache)
    orphanedBlobUpsertCacheMut       sync.RWMutex
    orphanedBlobUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    packageAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    packageAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    packageAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    packageAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    packageAnnotationType                 = reflect.TypeOf(&PackageAnnotation{})
    packageAnnotationMapping              = queries.MakeStructMapping(packageAnnotationType)
    packageAnnotationPrimaryKeyMapping, _ = queries.BindMapping(packageAnnotationType, packageAnnotationMapping, packageAnnotationPrimaryKeyColumns)
    packageAnnotationInsertCacheMut       sync.RWMutex
    packageAnnotationInsertCache          = make(map[string]insertCache)
    packageAnnotationUpdateCacheMut       sync.RWMutex
    packageAnnotationUpdateCache          = make(map[string]updateCache)
    packageAnnotationUpsertCacheMut       sync.RWMutex
    packageAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    packageLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    packageLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    packageLabelColumnsWithDefault    = []string{"id", "created_at"}
    packageLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    packageLabelType                 = reflect.TypeOf(&PackageLabel{})
    packageLabelMapping              = queries.MakeStructMapping(packageLabelType)
    packageLabelPrimaryKeyMapping, _ = queries.BindMapping(packageLabelType, packageLabelMapping, packageLabelPrimaryKeyColumns)
    packageLabelInsertCacheMut       sync.RWMutex
    packageLabelInsertCache          = make(map[string]insertCache)
    packageLabelUpdateCacheMut       sync.RWMutex
    packageLabelUpdateCache          = make(map[string]updateCache)
    packageLabelUpsertCacheMut       sync.RWMutex
    packageLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    packageAllColumns            = []string{"id", "guid", "created_at", "updated_at", "type", "package_hash", "state", "error", "app_guid", "docker_image", "sha256_checksum", "docker_username", "docker_password_salt", "encrypted_docker_password", "encryption_key_label", "encryption_iterations"}
    packageColumnsWithoutDefault = []string{"guid", "updated_at", "type", "package_hash", "state", "error", "app_guid", "docker_image", "sha256_checksum", "docker_username", "docker_password_salt", "encrypted_docker_password", "encryption_key_label"}
    packageColumnsWithDefault    = []string{"id", "created_at", "encryption_iterations"}
    packagePrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    packageType                 = reflect.TypeOf(&Package{})
    packageMapping              = queries.MakeStructMapping(packageType)
    packagePrimaryKeyMapping, _ = queries.BindMapping(packageType, packageMapping, packagePrimaryKeyColumns)
    packageInsertCacheMut       sync.RWMutex
    packageInsertCache          = make(map[string]insertCache)
    packageUpdateCacheMut       sync.RWMutex
    packageUpdateCache          = make(map[string]updateCache)
    packageUpsertCacheMut       sync.RWMutex
    packageUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    processAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    processAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    processAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    processAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    processAnnotationType                 = reflect.TypeOf(&ProcessAnnotation{})
    processAnnotationMapping              = queries.MakeStructMapping(processAnnotationType)
    processAnnotationPrimaryKeyMapping, _ = queries.BindMapping(processAnnotationType, processAnnotationMapping, processAnnotationPrimaryKeyColumns)
    processAnnotationInsertCacheMut       sync.RWMutex
    processAnnotationInsertCache          = make(map[string]insertCache)
    processAnnotationUpdateCacheMut       sync.RWMutex
    processAnnotationUpdateCache          = make(map[string]updateCache)
    processAnnotationUpsertCacheMut       sync.RWMutex
    processAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    processLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    processLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    processLabelColumnsWithDefault    = []string{"id", "created_at"}
    processLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    processLabelType                 = reflect.TypeOf(&ProcessLabel{})
    processLabelMapping              = queries.MakeStructMapping(processLabelType)
    processLabelPrimaryKeyMapping, _ = queries.BindMapping(processLabelType, processLabelMapping, processLabelPrimaryKeyColumns)
    processLabelInsertCacheMut       sync.RWMutex
    processLabelInsertCache          = make(map[string]insertCache)
    processLabelUpdateCacheMut       sync.RWMutex
    processLabelUpdateCache          = make(map[string]updateCache)
    processLabelUpsertCacheMut       sync.RWMutex
    processLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    processAllColumns            = []string{"id", "guid", "created_at", "updated_at", "production", "memory", "instances", "file_descriptors", "disk_quota", "state", "version", "metadata", "detected_buildpack", "not_deleted", "health_check_timeout", "diego", "package_updated_at", "app_guid", "type", "health_check_type", "command", "enable_ssh", "encrypted_docker_credentials_json", "docker_salt", "ports", "health_check_http_endpoint", "health_check_invocation_timeout", "revision_guid"}
    processColumnsWithoutDefault = []string{"guid", "updated_at", "memory", "version", "detected_buildpack", "health_check_timeout", "package_updated_at", "app_guid", "command", "encrypted_docker_credentials_json", "docker_salt", "ports", "health_check_http_endpoint", "health_check_invocation_timeout", "revision_guid"}
    processColumnsWithDefault    = []string{"id", "created_at", "production", "instances", "file_descriptors", "disk_quota", "state", "metadata", "not_deleted", "diego", "type", "health_check_type", "enable_ssh"}
    processPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    processType                 = reflect.TypeOf(&Process{})
    processMapping              = queries.MakeStructMapping(processType)
    processPrimaryKeyMapping, _ = queries.BindMapping(processType, processMapping, processPrimaryKeyColumns)
    processInsertCacheMut       sync.RWMutex
    processInsertCache          = make(map[string]insertCache)
    processUpdateCacheMut       sync.RWMutex
    processUpdateCache          = make(map[string]updateCache)
    processUpsertCacheMut       sync.RWMutex
    processUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    quotaDefinitionAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "non_basic_services_allowed", "total_services", "memory_limit", "total_routes", "instance_memory_limit", "total_private_domains", "app_instance_limit", "app_task_limit", "total_service_keys", "total_reserved_route_ports"}
    quotaDefinitionColumnsWithoutDefault = []string{"guid", "updated_at", "name", "non_basic_services_allowed", "total_services", "memory_limit", "total_routes"}
    quotaDefinitionColumnsWithDefault    = []string{"id", "created_at", "instance_memory_limit", "total_private_domains", "app_instance_limit", "app_task_limit", "total_service_keys", "total_reserved_route_ports"}
    quotaDefinitionPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    quotaDefinitionType                 = reflect.TypeOf(&QuotaDefinition{})
    quotaDefinitionMapping              = queries.MakeStructMapping(quotaDefinitionType)
    quotaDefinitionPrimaryKeyMapping, _ = queries.BindMapping(quotaDefinitionType, quotaDefinitionMapping, quotaDefinitionPrimaryKeyColumns)
    quotaDefinitionInsertCacheMut       sync.RWMutex
    quotaDefinitionInsertCache          = make(map[string]insertCache)
    quotaDefinitionUpdateCacheMut       sync.RWMutex
    quotaDefinitionUpdateCache          = make(map[string]updateCache)
    quotaDefinitionUpsertCacheMut       sync.RWMutex
    quotaDefinitionUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    requestCountAllColumns            = []string{"id", "user_guid", "count", "valid_until"}
    requestCountColumnsWithoutDefault = []string{"user_guid", "valid_until"}
    requestCountColumnsWithDefault    = []string{"id", "count"}
    requestCountPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    requestCountType                 = reflect.TypeOf(&RequestCount{})
    requestCountMapping              = queries.MakeStructMapping(requestCountType)
    requestCountPrimaryKeyMapping, _ = queries.BindMapping(requestCountType, requestCountMapping, requestCountPrimaryKeyColumns)
    requestCountInsertCacheMut       sync.RWMutex
    requestCountInsertCache          = make(map[string]insertCache)
    requestCountUpdateCacheMut       sync.RWMutex
    requestCountUpdateCache          = make(map[string]updateCache)
    requestCountUpsertCacheMut       sync.RWMutex
    requestCountUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    revisionAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    revisionAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    revisionAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    revisionAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    revisionAnnotationType                 = reflect.TypeOf(&RevisionAnnotation{})
    revisionAnnotationMapping              = queries.MakeStructMapping(revisionAnnotationType)
    revisionAnnotationPrimaryKeyMapping, _ = queries.BindMapping(revisionAnnotationType, revisionAnnotationMapping, revisionAnnotationPrimaryKeyColumns)
    revisionAnnotationInsertCacheMut       sync.RWMutex
    revisionAnnotationInsertCache          = make(map[string]insertCache)
    revisionAnnotationUpdateCacheMut       sync.RWMutex
    revisionAnnotationUpdateCache          = make(map[string]updateCache)
    revisionAnnotationUpsertCacheMut       sync.RWMutex
    revisionAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    revisionLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    revisionLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    revisionLabelColumnsWithDefault    = []string{"id", "created_at"}
    revisionLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    revisionLabelType                 = reflect.TypeOf(&RevisionLabel{})
    revisionLabelMapping              = queries.MakeStructMapping(revisionLabelType)
    revisionLabelPrimaryKeyMapping, _ = queries.BindMapping(revisionLabelType, revisionLabelMapping, revisionLabelPrimaryKeyColumns)
    revisionLabelInsertCacheMut       sync.RWMutex
    revisionLabelInsertCache          = make(map[string]insertCache)
    revisionLabelUpdateCacheMut       sync.RWMutex
    revisionLabelUpdateCache          = make(map[string]updateCache)
    revisionLabelUpsertCacheMut       sync.RWMutex
    revisionLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    revisionProcessCommandAllColumns            = []string{"id", "guid", "created_at", "updated_at", "revision_guid", "process_type", "process_command"}
    revisionProcessCommandColumnsWithoutDefault = []string{"guid", "updated_at", "revision_guid", "process_type", "process_command"}
    revisionProcessCommandColumnsWithDefault    = []string{"id", "created_at"}
    revisionProcessCommandPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    revisionProcessCommandType                 = reflect.TypeOf(&RevisionProcessCommand{})
    revisionProcessCommandMapping              = queries.MakeStructMapping(revisionProcessCommandType)
    revisionProcessCommandPrimaryKeyMapping, _ = queries.BindMapping(revisionProcessCommandType, revisionProcessCommandMapping, revisionProcessCommandPrimaryKeyColumns)
    revisionProcessCommandInsertCacheMut       sync.RWMutex
    revisionProcessCommandInsertCache          = make(map[string]insertCache)
    revisionProcessCommandUpdateCacheMut       sync.RWMutex
    revisionProcessCommandUpdateCache          = make(map[string]updateCache)
    revisionProcessCommandUpsertCacheMut       sync.RWMutex
    revisionProcessCommandUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    revisionSidecarProcessTypeAllColumns            = []string{"id", "guid", "created_at", "updated_at", "type", "revision_sidecar_guid"}
    revisionSidecarProcessTypeColumnsWithoutDefault = []string{"guid", "updated_at", "type", "revision_sidecar_guid"}
    revisionSidecarProcessTypeColumnsWithDefault    = []string{"id", "created_at"}
    revisionSidecarProcessTypePrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    revisionSidecarProcessTypeType                 = reflect.TypeOf(&RevisionSidecarProcessType{})
    revisionSidecarProcessTypeMapping              = queries.MakeStructMapping(revisionSidecarProcessTypeType)
    revisionSidecarProcessTypePrimaryKeyMapping, _ = queries.BindMapping(revisionSidecarProcessTypeType, revisionSidecarProcessTypeMapping, revisionSidecarProcessTypePrimaryKeyColumns)
    revisionSidecarProcessTypeInsertCacheMut       sync.RWMutex
    revisionSidecarProcessTypeInsertCache          = make(map[string]insertCache)
    revisionSidecarProcessTypeUpdateCacheMut       sync.RWMutex
    revisionSidecarProcessTypeUpdateCache          = make(map[string]updateCache)
    revisionSidecarProcessTypeUpsertCacheMut       sync.RWMutex
    revisionSidecarProcessTypeUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    revisionSidecarAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "command", "revision_guid", "memory"}
    revisionSidecarColumnsWithoutDefault = []string{"guid", "updated_at", "name", "command", "revision_guid", "memory"}
    revisionSidecarColumnsWithDefault    = []string{"id", "created_at"}
    revisionSidecarPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    revisionSidecarType                 = reflect.TypeOf(&RevisionSidecar{})
    revisionSidecarMapping              = queries.MakeStructMapping(revisionSidecarType)
    revisionSidecarPrimaryKeyMapping, _ = queries.BindMapping(revisionSidecarType, revisionSidecarMapping, revisionSidecarPrimaryKeyColumns)
    revisionSidecarInsertCacheMut       sync.RWMutex
    revisionSidecarInsertCache          = make(map[string]insertCache)
    revisionSidecarUpdateCacheMut       sync.RWMutex
    revisionSidecarUpdateCache          = make(map[string]updateCache)
    revisionSidecarUpsertCacheMut       sync.RWMutex
    revisionSidecarUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    revisionAllColumns            = []string{"id", "guid", "created_at", "updated_at", "app_guid", "version", "droplet_guid", "encrypted_environment_variables", "salt", "encryption_key_label", "encryption_iterations", "description"}
    revisionColumnsWithoutDefault = []string{"guid", "updated_at", "app_guid", "droplet_guid", "encrypted_environment_variables", "salt", "encryption_key_label"}
    revisionColumnsWithDefault    = []string{"id", "created_at", "version", "encryption_iterations", "description"}
    revisionPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    revisionType                 = reflect.TypeOf(&Revision{})
    revisionMapping              = queries.MakeStructMapping(revisionType)
    revisionPrimaryKeyMapping, _ = queries.BindMapping(revisionType, revisionMapping, revisionPrimaryKeyColumns)
    revisionInsertCacheMut       sync.RWMutex
    revisionInsertCache          = make(map[string]insertCache)
    revisionUpdateCacheMut       sync.RWMutex
    revisionUpdateCache          = make(map[string]updateCache)
    revisionUpsertCacheMut       sync.RWMutex
    revisionUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    routeAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    routeAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    routeAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    routeAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    routeAnnotationType                 = reflect.TypeOf(&RouteAnnotation{})
    routeAnnotationMapping              = queries.MakeStructMapping(routeAnnotationType)
    routeAnnotationPrimaryKeyMapping, _ = queries.BindMapping(routeAnnotationType, routeAnnotationMapping, routeAnnotationPrimaryKeyColumns)
    routeAnnotationInsertCacheMut       sync.RWMutex
    routeAnnotationInsertCache          = make(map[string]insertCache)
    routeAnnotationUpdateCacheMut       sync.RWMutex
    routeAnnotationUpdateCache          = make(map[string]updateCache)
    routeAnnotationUpsertCacheMut       sync.RWMutex
    routeAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    routeBindingAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    routeBindingAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    routeBindingAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    routeBindingAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    routeBindingAnnotationType                 = reflect.TypeOf(&RouteBindingAnnotation{})
    routeBindingAnnotationMapping              = queries.MakeStructMapping(routeBindingAnnotationType)
    routeBindingAnnotationPrimaryKeyMapping, _ = queries.BindMapping(routeBindingAnnotationType, routeBindingAnnotationMapping, routeBindingAnnotationPrimaryKeyColumns)
    routeBindingAnnotationInsertCacheMut       sync.RWMutex
    routeBindingAnnotationInsertCache          = make(map[string]insertCache)
    routeBindingAnnotationUpdateCacheMut       sync.RWMutex
    routeBindingAnnotationUpdateCache          = make(map[string]updateCache)
    routeBindingAnnotationUpsertCacheMut       sync.RWMutex
    routeBindingAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    routeBindingLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    routeBindingLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    routeBindingLabelColumnsWithDefault    = []string{"id", "created_at"}
    routeBindingLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    routeBindingLabelType                 = reflect.TypeOf(&RouteBindingLabel{})
    routeBindingLabelMapping              = queries.MakeStructMapping(routeBindingLabelType)
    routeBindingLabelPrimaryKeyMapping, _ = queries.BindMapping(routeBindingLabelType, routeBindingLabelMapping, routeBindingLabelPrimaryKeyColumns)
    routeBindingLabelInsertCacheMut       sync.RWMutex
    routeBindingLabelInsertCache          = make(map[string]insertCache)
    routeBindingLabelUpdateCacheMut       sync.RWMutex
    routeBindingLabelUpdateCache          = make(map[string]updateCache)
    routeBindingLabelUpsertCacheMut       sync.RWMutex
    routeBindingLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    routeBindingOperationAllColumns            = []string{"id", "created_at", "updated_at", "route_binding_id", "state", "type", "description", "broker_provided_operation"}
    routeBindingOperationColumnsWithoutDefault = []string{"updated_at", "route_binding_id", "state", "type", "description", "broker_provided_operation"}
    routeBindingOperationColumnsWithDefault    = []string{"id", "created_at"}
    routeBindingOperationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    routeBindingOperationType                 = reflect.TypeOf(&RouteBindingOperation{})
    routeBindingOperationMapping              = queries.MakeStructMapping(routeBindingOperationType)
    routeBindingOperationPrimaryKeyMapping, _ = queries.BindMapping(routeBindingOperationType, routeBindingOperationMapping, routeBindingOperationPrimaryKeyColumns)
    routeBindingOperationInsertCacheMut       sync.RWMutex
    routeBindingOperationInsertCache          = make(map[string]insertCache)
    routeBindingOperationUpdateCacheMut       sync.RWMutex
    routeBindingOperationUpdateCache          = make(map[string]updateCache)
    routeBindingOperationUpsertCacheMut       sync.RWMutex
    routeBindingOperationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    routeBindingAllColumns            = []string{"id", "guid", "created_at", "updated_at", "route_id", "service_instance_id", "route_service_url"}
    routeBindingColumnsWithoutDefault = []string{"guid", "updated_at", "route_id", "service_instance_id", "route_service_url"}
    routeBindingColumnsWithDefault    = []string{"id", "created_at"}
    routeBindingPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    routeBindingType                 = reflect.TypeOf(&RouteBinding{})
    routeBindingMapping              = queries.MakeStructMapping(routeBindingType)
    routeBindingPrimaryKeyMapping, _ = queries.BindMapping(routeBindingType, routeBindingMapping, routeBindingPrimaryKeyColumns)
    routeBindingInsertCacheMut       sync.RWMutex
    routeBindingInsertCache          = make(map[string]insertCache)
    routeBindingUpdateCacheMut       sync.RWMutex
    routeBindingUpdateCache          = make(map[string]updateCache)
    routeBindingUpsertCacheMut       sync.RWMutex
    routeBindingUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    routeLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    routeLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    routeLabelColumnsWithDefault    = []string{"id", "created_at"}
    routeLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    routeLabelType                 = reflect.TypeOf(&RouteLabel{})
    routeLabelMapping              = queries.MakeStructMapping(routeLabelType)
    routeLabelPrimaryKeyMapping, _ = queries.BindMapping(routeLabelType, routeLabelMapping, routeLabelPrimaryKeyColumns)
    routeLabelInsertCacheMut       sync.RWMutex
    routeLabelInsertCache          = make(map[string]insertCache)
    routeLabelUpdateCacheMut       sync.RWMutex
    routeLabelUpdateCache          = make(map[string]updateCache)
    routeLabelUpsertCacheMut       sync.RWMutex
    routeLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    routeMappingAllColumns            = []string{"id", "created_at", "updated_at", "app_port", "guid", "app_guid", "route_guid", "process_type", "weight"}
    routeMappingColumnsWithoutDefault = []string{"updated_at", "guid", "app_guid", "route_guid", "process_type", "weight"}
    routeMappingColumnsWithDefault    = []string{"id", "created_at", "app_port"}
    routeMappingPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    routeMappingType                 = reflect.TypeOf(&RouteMapping{})
    routeMappingMapping              = queries.MakeStructMapping(routeMappingType)
    routeMappingPrimaryKeyMapping, _ = queries.BindMapping(routeMappingType, routeMappingMapping, routeMappingPrimaryKeyColumns)
    routeMappingInsertCacheMut       sync.RWMutex
    routeMappingInsertCache          = make(map[string]insertCache)
    routeMappingUpdateCacheMut       sync.RWMutex
    routeMappingUpdateCache          = make(map[string]updateCache)
    routeMappingUpsertCacheMut       sync.RWMutex
    routeMappingUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    routeAllColumns            = []string{"id", "guid", "created_at", "updated_at", "host", "domain_id", "space_id", "path", "port", "vip_offset"}
    routeColumnsWithoutDefault = []string{"guid", "updated_at", "domain_id", "space_id", "vip_offset"}
    routeColumnsWithDefault    = []string{"id", "created_at", "host", "path", "port"}
    routePrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    routeType                 = reflect.TypeOf(&Route{})
    routeMapping              = queries.MakeStructMapping(routeType)
    routePrimaryKeyMapping, _ = queries.BindMapping(routeType, routeMapping, routePrimaryKeyColumns)
    routeInsertCacheMut       sync.RWMutex
    routeInsertCache          = make(map[string]insertCache)
    routeUpdateCacheMut       sync.RWMutex
    routeUpdateCache          = make(map[string]updateCache)
    routeUpsertCacheMut       sync.RWMutex
    routeUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    schemaMigrationAllColumns            = []string{"filename"}
    schemaMigrationColumnsWithoutDefault = []string{"filename"}
    schemaMigrationColumnsWithDefault    = []string{}
    schemaMigrationPrimaryKeyColumns     = []string{"filename"}
)

Cache for insert\, update and upsert

var (
    schemaMigrationType                 = reflect.TypeOf(&SchemaMigration{})
    schemaMigrationMapping              = queries.MakeStructMapping(schemaMigrationType)
    schemaMigrationPrimaryKeyMapping, _ = queries.BindMapping(schemaMigrationType, schemaMigrationMapping, schemaMigrationPrimaryKeyColumns)
    schemaMigrationInsertCacheMut       sync.RWMutex
    schemaMigrationInsertCache          = make(map[string]insertCache)
    schemaMigrationUpdateCacheMut       sync.RWMutex
    schemaMigrationUpdateCache          = make(map[string]updateCache)
    schemaMigrationUpsertCacheMut       sync.RWMutex
    schemaMigrationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    securityGroupAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "rules", "staging_default", "running_default"}
    securityGroupColumnsWithoutDefault = []string{"guid", "updated_at", "name", "rules"}
    securityGroupColumnsWithDefault    = []string{"id", "created_at", "staging_default", "running_default"}
    securityGroupPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    securityGroupType                 = reflect.TypeOf(&SecurityGroup{})
    securityGroupMapping              = queries.MakeStructMapping(securityGroupType)
    securityGroupPrimaryKeyMapping, _ = queries.BindMapping(securityGroupType, securityGroupMapping, securityGroupPrimaryKeyColumns)
    securityGroupInsertCacheMut       sync.RWMutex
    securityGroupInsertCache          = make(map[string]insertCache)
    securityGroupUpdateCacheMut       sync.RWMutex
    securityGroupUpdateCache          = make(map[string]updateCache)
    securityGroupUpsertCacheMut       sync.RWMutex
    securityGroupUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    securityGroupsSpaceAllColumns            = []string{"security_group_id", "space_id", "security_groups_spaces_pk"}
    securityGroupsSpaceColumnsWithoutDefault = []string{"security_group_id", "space_id"}
    securityGroupsSpaceColumnsWithDefault    = []string{"security_groups_spaces_pk"}
    securityGroupsSpacePrimaryKeyColumns     = []string{"security_groups_spaces_pk"}
)

Cache for insert\, update and upsert

var (
    securityGroupsSpaceType                 = reflect.TypeOf(&SecurityGroupsSpace{})
    securityGroupsSpaceMapping              = queries.MakeStructMapping(securityGroupsSpaceType)
    securityGroupsSpacePrimaryKeyMapping, _ = queries.BindMapping(securityGroupsSpaceType, securityGroupsSpaceMapping, securityGroupsSpacePrimaryKeyColumns)
    securityGroupsSpaceInsertCacheMut       sync.RWMutex
    securityGroupsSpaceInsertCache          = make(map[string]insertCache)
    securityGroupsSpaceUpdateCacheMut       sync.RWMutex
    securityGroupsSpaceUpdateCache          = make(map[string]updateCache)
    securityGroupsSpaceUpsertCacheMut       sync.RWMutex
    securityGroupsSpaceUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceBindingAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceBindingAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceBindingAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    serviceBindingAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceBindingAnnotationType                 = reflect.TypeOf(&ServiceBindingAnnotation{})
    serviceBindingAnnotationMapping              = queries.MakeStructMapping(serviceBindingAnnotationType)
    serviceBindingAnnotationPrimaryKeyMapping, _ = queries.BindMapping(serviceBindingAnnotationType, serviceBindingAnnotationMapping, serviceBindingAnnotationPrimaryKeyColumns)
    serviceBindingAnnotationInsertCacheMut       sync.RWMutex
    serviceBindingAnnotationInsertCache          = make(map[string]insertCache)
    serviceBindingAnnotationUpdateCacheMut       sync.RWMutex
    serviceBindingAnnotationUpdateCache          = make(map[string]updateCache)
    serviceBindingAnnotationUpsertCacheMut       sync.RWMutex
    serviceBindingAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceBindingLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceBindingLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceBindingLabelColumnsWithDefault    = []string{"id", "created_at"}
    serviceBindingLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceBindingLabelType                 = reflect.TypeOf(&ServiceBindingLabel{})
    serviceBindingLabelMapping              = queries.MakeStructMapping(serviceBindingLabelType)
    serviceBindingLabelPrimaryKeyMapping, _ = queries.BindMapping(serviceBindingLabelType, serviceBindingLabelMapping, serviceBindingLabelPrimaryKeyColumns)
    serviceBindingLabelInsertCacheMut       sync.RWMutex
    serviceBindingLabelInsertCache          = make(map[string]insertCache)
    serviceBindingLabelUpdateCacheMut       sync.RWMutex
    serviceBindingLabelUpdateCache          = make(map[string]updateCache)
    serviceBindingLabelUpsertCacheMut       sync.RWMutex
    serviceBindingLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceBindingOperationAllColumns            = []string{"id", "created_at", "updated_at", "service_binding_id", "state", "type", "description", "broker_provided_operation"}
    serviceBindingOperationColumnsWithoutDefault = []string{"updated_at", "service_binding_id", "state", "type", "description", "broker_provided_operation"}
    serviceBindingOperationColumnsWithDefault    = []string{"id", "created_at"}
    serviceBindingOperationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceBindingOperationType                 = reflect.TypeOf(&ServiceBindingOperation{})
    serviceBindingOperationMapping              = queries.MakeStructMapping(serviceBindingOperationType)
    serviceBindingOperationPrimaryKeyMapping, _ = queries.BindMapping(serviceBindingOperationType, serviceBindingOperationMapping, serviceBindingOperationPrimaryKeyColumns)
    serviceBindingOperationInsertCacheMut       sync.RWMutex
    serviceBindingOperationInsertCache          = make(map[string]insertCache)
    serviceBindingOperationUpdateCacheMut       sync.RWMutex
    serviceBindingOperationUpdateCache          = make(map[string]updateCache)
    serviceBindingOperationUpsertCacheMut       sync.RWMutex
    serviceBindingOperationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceBindingAllColumns            = []string{"id", "guid", "created_at", "updated_at", "credentials", "salt", "syslog_drain_url", "volume_mounts", "volume_mounts_salt", "app_guid", "service_instance_guid", "type", "name", "encryption_key_label", "encryption_iterations"}
    serviceBindingColumnsWithoutDefault = []string{"guid", "updated_at", "credentials", "salt", "syslog_drain_url", "volume_mounts", "volume_mounts_salt", "app_guid", "service_instance_guid", "type", "name", "encryption_key_label"}
    serviceBindingColumnsWithDefault    = []string{"id", "created_at", "encryption_iterations"}
    serviceBindingPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceBindingType                 = reflect.TypeOf(&ServiceBinding{})
    serviceBindingMapping              = queries.MakeStructMapping(serviceBindingType)
    serviceBindingPrimaryKeyMapping, _ = queries.BindMapping(serviceBindingType, serviceBindingMapping, serviceBindingPrimaryKeyColumns)
    serviceBindingInsertCacheMut       sync.RWMutex
    serviceBindingInsertCache          = make(map[string]insertCache)
    serviceBindingUpdateCacheMut       sync.RWMutex
    serviceBindingUpdateCache          = make(map[string]updateCache)
    serviceBindingUpsertCacheMut       sync.RWMutex
    serviceBindingUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceBrokerAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceBrokerAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceBrokerAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    serviceBrokerAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceBrokerAnnotationType                 = reflect.TypeOf(&ServiceBrokerAnnotation{})
    serviceBrokerAnnotationMapping              = queries.MakeStructMapping(serviceBrokerAnnotationType)
    serviceBrokerAnnotationPrimaryKeyMapping, _ = queries.BindMapping(serviceBrokerAnnotationType, serviceBrokerAnnotationMapping, serviceBrokerAnnotationPrimaryKeyColumns)
    serviceBrokerAnnotationInsertCacheMut       sync.RWMutex
    serviceBrokerAnnotationInsertCache          = make(map[string]insertCache)
    serviceBrokerAnnotationUpdateCacheMut       sync.RWMutex
    serviceBrokerAnnotationUpdateCache          = make(map[string]updateCache)
    serviceBrokerAnnotationUpsertCacheMut       sync.RWMutex
    serviceBrokerAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceBrokerLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceBrokerLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceBrokerLabelColumnsWithDefault    = []string{"id", "created_at"}
    serviceBrokerLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceBrokerLabelType                 = reflect.TypeOf(&ServiceBrokerLabel{})
    serviceBrokerLabelMapping              = queries.MakeStructMapping(serviceBrokerLabelType)
    serviceBrokerLabelPrimaryKeyMapping, _ = queries.BindMapping(serviceBrokerLabelType, serviceBrokerLabelMapping, serviceBrokerLabelPrimaryKeyColumns)
    serviceBrokerLabelInsertCacheMut       sync.RWMutex
    serviceBrokerLabelInsertCache          = make(map[string]insertCache)
    serviceBrokerLabelUpdateCacheMut       sync.RWMutex
    serviceBrokerLabelUpdateCache          = make(map[string]updateCache)
    serviceBrokerLabelUpsertCacheMut       sync.RWMutex
    serviceBrokerLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceBrokerUpdateRequestAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceBrokerUpdateRequestAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceBrokerUpdateRequestAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    serviceBrokerUpdateRequestAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceBrokerUpdateRequestAnnotationType                 = reflect.TypeOf(&ServiceBrokerUpdateRequestAnnotation{})
    serviceBrokerUpdateRequestAnnotationMapping              = queries.MakeStructMapping(serviceBrokerUpdateRequestAnnotationType)
    serviceBrokerUpdateRequestAnnotationPrimaryKeyMapping, _ = queries.BindMapping(serviceBrokerUpdateRequestAnnotationType, serviceBrokerUpdateRequestAnnotationMapping, serviceBrokerUpdateRequestAnnotationPrimaryKeyColumns)
    serviceBrokerUpdateRequestAnnotationInsertCacheMut       sync.RWMutex
    serviceBrokerUpdateRequestAnnotationInsertCache          = make(map[string]insertCache)
    serviceBrokerUpdateRequestAnnotationUpdateCacheMut       sync.RWMutex
    serviceBrokerUpdateRequestAnnotationUpdateCache          = make(map[string]updateCache)
    serviceBrokerUpdateRequestAnnotationUpsertCacheMut       sync.RWMutex
    serviceBrokerUpdateRequestAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceBrokerUpdateRequestLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceBrokerUpdateRequestLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceBrokerUpdateRequestLabelColumnsWithDefault    = []string{"id", "created_at"}
    serviceBrokerUpdateRequestLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceBrokerUpdateRequestLabelType                 = reflect.TypeOf(&ServiceBrokerUpdateRequestLabel{})
    serviceBrokerUpdateRequestLabelMapping              = queries.MakeStructMapping(serviceBrokerUpdateRequestLabelType)
    serviceBrokerUpdateRequestLabelPrimaryKeyMapping, _ = queries.BindMapping(serviceBrokerUpdateRequestLabelType, serviceBrokerUpdateRequestLabelMapping, serviceBrokerUpdateRequestLabelPrimaryKeyColumns)
    serviceBrokerUpdateRequestLabelInsertCacheMut       sync.RWMutex
    serviceBrokerUpdateRequestLabelInsertCache          = make(map[string]insertCache)
    serviceBrokerUpdateRequestLabelUpdateCacheMut       sync.RWMutex
    serviceBrokerUpdateRequestLabelUpdateCache          = make(map[string]updateCache)
    serviceBrokerUpdateRequestLabelUpsertCacheMut       sync.RWMutex
    serviceBrokerUpdateRequestLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceBrokerUpdateRequestAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "broker_url", "authentication", "salt", "encryption_key_label", "encryption_iterations", "service_broker_id", "fk_service_brokers_id"}
    serviceBrokerUpdateRequestColumnsWithoutDefault = []string{"guid", "updated_at", "name", "broker_url", "authentication", "salt", "encryption_key_label", "service_broker_id", "fk_service_brokers_id"}
    serviceBrokerUpdateRequestColumnsWithDefault    = []string{"id", "created_at", "encryption_iterations"}
    serviceBrokerUpdateRequestPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceBrokerUpdateRequestType                 = reflect.TypeOf(&ServiceBrokerUpdateRequest{})
    serviceBrokerUpdateRequestMapping              = queries.MakeStructMapping(serviceBrokerUpdateRequestType)
    serviceBrokerUpdateRequestPrimaryKeyMapping, _ = queries.BindMapping(serviceBrokerUpdateRequestType, serviceBrokerUpdateRequestMapping, serviceBrokerUpdateRequestPrimaryKeyColumns)
    serviceBrokerUpdateRequestInsertCacheMut       sync.RWMutex
    serviceBrokerUpdateRequestInsertCache          = make(map[string]insertCache)
    serviceBrokerUpdateRequestUpdateCacheMut       sync.RWMutex
    serviceBrokerUpdateRequestUpdateCache          = make(map[string]updateCache)
    serviceBrokerUpdateRequestUpsertCacheMut       sync.RWMutex
    serviceBrokerUpdateRequestUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceBrokerAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "broker_url", "auth_password", "salt", "auth_username", "space_id", "encryption_key_label", "encryption_iterations", "state"}
    serviceBrokerColumnsWithoutDefault = []string{"guid", "updated_at", "name", "broker_url", "auth_password", "salt", "auth_username", "space_id", "encryption_key_label"}
    serviceBrokerColumnsWithDefault    = []string{"id", "created_at", "encryption_iterations", "state"}
    serviceBrokerPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceBrokerType                 = reflect.TypeOf(&ServiceBroker{})
    serviceBrokerMapping              = queries.MakeStructMapping(serviceBrokerType)
    serviceBrokerPrimaryKeyMapping, _ = queries.BindMapping(serviceBrokerType, serviceBrokerMapping, serviceBrokerPrimaryKeyColumns)
    serviceBrokerInsertCacheMut       sync.RWMutex
    serviceBrokerInsertCache          = make(map[string]insertCache)
    serviceBrokerUpdateCacheMut       sync.RWMutex
    serviceBrokerUpdateCache          = make(map[string]updateCache)
    serviceBrokerUpsertCacheMut       sync.RWMutex
    serviceBrokerUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceDashboardClientAllColumns            = []string{"id", "created_at", "updated_at", "uaa_id", "service_broker_id"}
    serviceDashboardClientColumnsWithoutDefault = []string{"updated_at", "uaa_id", "service_broker_id"}
    serviceDashboardClientColumnsWithDefault    = []string{"id", "created_at"}
    serviceDashboardClientPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceDashboardClientType                 = reflect.TypeOf(&ServiceDashboardClient{})
    serviceDashboardClientMapping              = queries.MakeStructMapping(serviceDashboardClientType)
    serviceDashboardClientPrimaryKeyMapping, _ = queries.BindMapping(serviceDashboardClientType, serviceDashboardClientMapping, serviceDashboardClientPrimaryKeyColumns)
    serviceDashboardClientInsertCacheMut       sync.RWMutex
    serviceDashboardClientInsertCache          = make(map[string]insertCache)
    serviceDashboardClientUpdateCacheMut       sync.RWMutex
    serviceDashboardClientUpdateCache          = make(map[string]updateCache)
    serviceDashboardClientUpsertCacheMut       sync.RWMutex
    serviceDashboardClientUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceInstanceAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceInstanceAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceInstanceAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    serviceInstanceAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceInstanceAnnotationType                 = reflect.TypeOf(&ServiceInstanceAnnotation{})
    serviceInstanceAnnotationMapping              = queries.MakeStructMapping(serviceInstanceAnnotationType)
    serviceInstanceAnnotationPrimaryKeyMapping, _ = queries.BindMapping(serviceInstanceAnnotationType, serviceInstanceAnnotationMapping, serviceInstanceAnnotationPrimaryKeyColumns)
    serviceInstanceAnnotationInsertCacheMut       sync.RWMutex
    serviceInstanceAnnotationInsertCache          = make(map[string]insertCache)
    serviceInstanceAnnotationUpdateCacheMut       sync.RWMutex
    serviceInstanceAnnotationUpdateCache          = make(map[string]updateCache)
    serviceInstanceAnnotationUpsertCacheMut       sync.RWMutex
    serviceInstanceAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceInstanceLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceInstanceLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceInstanceLabelColumnsWithDefault    = []string{"id", "created_at"}
    serviceInstanceLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceInstanceLabelType                 = reflect.TypeOf(&ServiceInstanceLabel{})
    serviceInstanceLabelMapping              = queries.MakeStructMapping(serviceInstanceLabelType)
    serviceInstanceLabelPrimaryKeyMapping, _ = queries.BindMapping(serviceInstanceLabelType, serviceInstanceLabelMapping, serviceInstanceLabelPrimaryKeyColumns)
    serviceInstanceLabelInsertCacheMut       sync.RWMutex
    serviceInstanceLabelInsertCache          = make(map[string]insertCache)
    serviceInstanceLabelUpdateCacheMut       sync.RWMutex
    serviceInstanceLabelUpdateCache          = make(map[string]updateCache)
    serviceInstanceLabelUpsertCacheMut       sync.RWMutex
    serviceInstanceLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceInstanceOperationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "service_instance_id", "type", "state", "description", "proposed_changes", "broker_provided_operation"}
    serviceInstanceOperationColumnsWithoutDefault = []string{"guid", "updated_at", "service_instance_id", "type", "state", "description", "broker_provided_operation"}
    serviceInstanceOperationColumnsWithDefault    = []string{"id", "created_at", "proposed_changes"}
    serviceInstanceOperationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceInstanceOperationType                 = reflect.TypeOf(&ServiceInstanceOperation{})
    serviceInstanceOperationMapping              = queries.MakeStructMapping(serviceInstanceOperationType)
    serviceInstanceOperationPrimaryKeyMapping, _ = queries.BindMapping(serviceInstanceOperationType, serviceInstanceOperationMapping, serviceInstanceOperationPrimaryKeyColumns)
    serviceInstanceOperationInsertCacheMut       sync.RWMutex
    serviceInstanceOperationInsertCache          = make(map[string]insertCache)
    serviceInstanceOperationUpdateCacheMut       sync.RWMutex
    serviceInstanceOperationUpdateCache          = make(map[string]updateCache)
    serviceInstanceOperationUpsertCacheMut       sync.RWMutex
    serviceInstanceOperationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceInstanceAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "credentials", "gateway_name", "gateway_data", "space_id", "service_plan_id", "salt", "dashboard_url", "is_gateway_service", "syslog_drain_url", "tags", "route_service_url", "encryption_key_label", "encryption_iterations", "maintenance_info"}
    serviceInstanceColumnsWithoutDefault = []string{"guid", "updated_at", "name", "credentials", "gateway_name", "gateway_data", "space_id", "service_plan_id", "salt", "dashboard_url", "syslog_drain_url", "tags", "route_service_url", "encryption_key_label", "maintenance_info"}
    serviceInstanceColumnsWithDefault    = []string{"id", "created_at", "is_gateway_service", "encryption_iterations"}
    serviceInstancePrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceInstanceType                 = reflect.TypeOf(&ServiceInstance{})
    serviceInstanceMapping              = queries.MakeStructMapping(serviceInstanceType)
    serviceInstancePrimaryKeyMapping, _ = queries.BindMapping(serviceInstanceType, serviceInstanceMapping, serviceInstancePrimaryKeyColumns)
    serviceInstanceInsertCacheMut       sync.RWMutex
    serviceInstanceInsertCache          = make(map[string]insertCache)
    serviceInstanceUpdateCacheMut       sync.RWMutex
    serviceInstanceUpdateCache          = make(map[string]updateCache)
    serviceInstanceUpsertCacheMut       sync.RWMutex
    serviceInstanceUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceKeyAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceKeyAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceKeyAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    serviceKeyAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceKeyAnnotationType                 = reflect.TypeOf(&ServiceKeyAnnotation{})
    serviceKeyAnnotationMapping              = queries.MakeStructMapping(serviceKeyAnnotationType)
    serviceKeyAnnotationPrimaryKeyMapping, _ = queries.BindMapping(serviceKeyAnnotationType, serviceKeyAnnotationMapping, serviceKeyAnnotationPrimaryKeyColumns)
    serviceKeyAnnotationInsertCacheMut       sync.RWMutex
    serviceKeyAnnotationInsertCache          = make(map[string]insertCache)
    serviceKeyAnnotationUpdateCacheMut       sync.RWMutex
    serviceKeyAnnotationUpdateCache          = make(map[string]updateCache)
    serviceKeyAnnotationUpsertCacheMut       sync.RWMutex
    serviceKeyAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceKeyLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceKeyLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceKeyLabelColumnsWithDefault    = []string{"id", "created_at"}
    serviceKeyLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceKeyLabelType                 = reflect.TypeOf(&ServiceKeyLabel{})
    serviceKeyLabelMapping              = queries.MakeStructMapping(serviceKeyLabelType)
    serviceKeyLabelPrimaryKeyMapping, _ = queries.BindMapping(serviceKeyLabelType, serviceKeyLabelMapping, serviceKeyLabelPrimaryKeyColumns)
    serviceKeyLabelInsertCacheMut       sync.RWMutex
    serviceKeyLabelInsertCache          = make(map[string]insertCache)
    serviceKeyLabelUpdateCacheMut       sync.RWMutex
    serviceKeyLabelUpdateCache          = make(map[string]updateCache)
    serviceKeyLabelUpsertCacheMut       sync.RWMutex
    serviceKeyLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceKeyOperationAllColumns            = []string{"id", "created_at", "updated_at", "service_key_id", "state", "type", "description", "broker_provided_operation"}
    serviceKeyOperationColumnsWithoutDefault = []string{"updated_at", "service_key_id", "state", "type", "description", "broker_provided_operation"}
    serviceKeyOperationColumnsWithDefault    = []string{"id", "created_at"}
    serviceKeyOperationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceKeyOperationType                 = reflect.TypeOf(&ServiceKeyOperation{})
    serviceKeyOperationMapping              = queries.MakeStructMapping(serviceKeyOperationType)
    serviceKeyOperationPrimaryKeyMapping, _ = queries.BindMapping(serviceKeyOperationType, serviceKeyOperationMapping, serviceKeyOperationPrimaryKeyColumns)
    serviceKeyOperationInsertCacheMut       sync.RWMutex
    serviceKeyOperationInsertCache          = make(map[string]insertCache)
    serviceKeyOperationUpdateCacheMut       sync.RWMutex
    serviceKeyOperationUpdateCache          = make(map[string]updateCache)
    serviceKeyOperationUpsertCacheMut       sync.RWMutex
    serviceKeyOperationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceKeyAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "salt", "credentials", "service_instance_id", "encryption_key_label", "encryption_iterations"}
    serviceKeyColumnsWithoutDefault = []string{"guid", "updated_at", "name", "salt", "credentials", "service_instance_id", "encryption_key_label"}
    serviceKeyColumnsWithDefault    = []string{"id", "created_at", "encryption_iterations"}
    serviceKeyPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceKeyType                 = reflect.TypeOf(&ServiceKey{})
    serviceKeyMapping              = queries.MakeStructMapping(serviceKeyType)
    serviceKeyPrimaryKeyMapping, _ = queries.BindMapping(serviceKeyType, serviceKeyMapping, serviceKeyPrimaryKeyColumns)
    serviceKeyInsertCacheMut       sync.RWMutex
    serviceKeyInsertCache          = make(map[string]insertCache)
    serviceKeyUpdateCacheMut       sync.RWMutex
    serviceKeyUpdateCache          = make(map[string]updateCache)
    serviceKeyUpsertCacheMut       sync.RWMutex
    serviceKeyUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceOfferingAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceOfferingAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    serviceOfferingAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    serviceOfferingAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceOfferingAnnotationType                 = reflect.TypeOf(&ServiceOfferingAnnotation{})
    serviceOfferingAnnotationMapping              = queries.MakeStructMapping(serviceOfferingAnnotationType)
    serviceOfferingAnnotationPrimaryKeyMapping, _ = queries.BindMapping(serviceOfferingAnnotationType, serviceOfferingAnnotationMapping, serviceOfferingAnnotationPrimaryKeyColumns)
    serviceOfferingAnnotationInsertCacheMut       sync.RWMutex
    serviceOfferingAnnotationInsertCache          = make(map[string]insertCache)
    serviceOfferingAnnotationUpdateCacheMut       sync.RWMutex
    serviceOfferingAnnotationUpdateCache          = make(map[string]updateCache)
    serviceOfferingAnnotationUpsertCacheMut       sync.RWMutex
    serviceOfferingAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceOfferingLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceOfferingLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    serviceOfferingLabelColumnsWithDefault    = []string{"id", "created_at"}
    serviceOfferingLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceOfferingLabelType                 = reflect.TypeOf(&ServiceOfferingLabel{})
    serviceOfferingLabelMapping              = queries.MakeStructMapping(serviceOfferingLabelType)
    serviceOfferingLabelPrimaryKeyMapping, _ = queries.BindMapping(serviceOfferingLabelType, serviceOfferingLabelMapping, serviceOfferingLabelPrimaryKeyColumns)
    serviceOfferingLabelInsertCacheMut       sync.RWMutex
    serviceOfferingLabelInsertCache          = make(map[string]insertCache)
    serviceOfferingLabelUpdateCacheMut       sync.RWMutex
    serviceOfferingLabelUpdateCache          = make(map[string]updateCache)
    serviceOfferingLabelUpsertCacheMut       sync.RWMutex
    serviceOfferingLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    servicePlanAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    servicePlanAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    servicePlanAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    servicePlanAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    servicePlanAnnotationType                 = reflect.TypeOf(&ServicePlanAnnotation{})
    servicePlanAnnotationMapping              = queries.MakeStructMapping(servicePlanAnnotationType)
    servicePlanAnnotationPrimaryKeyMapping, _ = queries.BindMapping(servicePlanAnnotationType, servicePlanAnnotationMapping, servicePlanAnnotationPrimaryKeyColumns)
    servicePlanAnnotationInsertCacheMut       sync.RWMutex
    servicePlanAnnotationInsertCache          = make(map[string]insertCache)
    servicePlanAnnotationUpdateCacheMut       sync.RWMutex
    servicePlanAnnotationUpdateCache          = make(map[string]updateCache)
    servicePlanAnnotationUpsertCacheMut       sync.RWMutex
    servicePlanAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    servicePlanLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    servicePlanLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    servicePlanLabelColumnsWithDefault    = []string{"id", "created_at"}
    servicePlanLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    servicePlanLabelType                 = reflect.TypeOf(&ServicePlanLabel{})
    servicePlanLabelMapping              = queries.MakeStructMapping(servicePlanLabelType)
    servicePlanLabelPrimaryKeyMapping, _ = queries.BindMapping(servicePlanLabelType, servicePlanLabelMapping, servicePlanLabelPrimaryKeyColumns)
    servicePlanLabelInsertCacheMut       sync.RWMutex
    servicePlanLabelInsertCache          = make(map[string]insertCache)
    servicePlanLabelUpdateCacheMut       sync.RWMutex
    servicePlanLabelUpdateCache          = make(map[string]updateCache)
    servicePlanLabelUpsertCacheMut       sync.RWMutex
    servicePlanLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    servicePlanVisibilityAllColumns            = []string{"id", "guid", "created_at", "updated_at", "service_plan_id", "organization_id"}
    servicePlanVisibilityColumnsWithoutDefault = []string{"guid", "updated_at", "service_plan_id", "organization_id"}
    servicePlanVisibilityColumnsWithDefault    = []string{"id", "created_at"}
    servicePlanVisibilityPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    servicePlanVisibilityType                 = reflect.TypeOf(&ServicePlanVisibility{})
    servicePlanVisibilityMapping              = queries.MakeStructMapping(servicePlanVisibilityType)
    servicePlanVisibilityPrimaryKeyMapping, _ = queries.BindMapping(servicePlanVisibilityType, servicePlanVisibilityMapping, servicePlanVisibilityPrimaryKeyColumns)
    servicePlanVisibilityInsertCacheMut       sync.RWMutex
    servicePlanVisibilityInsertCache          = make(map[string]insertCache)
    servicePlanVisibilityUpdateCacheMut       sync.RWMutex
    servicePlanVisibilityUpdateCache          = make(map[string]updateCache)
    servicePlanVisibilityUpsertCacheMut       sync.RWMutex
    servicePlanVisibilityUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    servicePlanAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "description", "free", "service_id", "extra", "unique_id", "public", "active", "bindable", "create_instance_schema", "update_instance_schema", "create_binding_schema", "plan_updateable", "maximum_polling_duration", "maintenance_info"}
    servicePlanColumnsWithoutDefault = []string{"guid", "updated_at", "name", "description", "free", "service_id", "extra", "unique_id", "bindable", "create_instance_schema", "update_instance_schema", "create_binding_schema", "plan_updateable", "maximum_polling_duration", "maintenance_info"}
    servicePlanColumnsWithDefault    = []string{"id", "created_at", "public", "active"}
    servicePlanPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    servicePlanType                 = reflect.TypeOf(&ServicePlan{})
    servicePlanMapping              = queries.MakeStructMapping(servicePlanType)
    servicePlanPrimaryKeyMapping, _ = queries.BindMapping(servicePlanType, servicePlanMapping, servicePlanPrimaryKeyColumns)
    servicePlanInsertCacheMut       sync.RWMutex
    servicePlanInsertCache          = make(map[string]insertCache)
    servicePlanUpdateCacheMut       sync.RWMutex
    servicePlanUpdateCache          = make(map[string]updateCache)
    servicePlanUpsertCacheMut       sync.RWMutex
    servicePlanUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceUsageEventAllColumns            = []string{"id", "guid", "created_at", "state", "org_guid", "space_guid", "space_name", "service_instance_guid", "service_instance_name", "service_instance_type", "service_plan_guid", "service_plan_name", "service_guid", "service_label", "service_broker_name", "service_broker_guid"}
    serviceUsageEventColumnsWithoutDefault = []string{"guid", "created_at", "state", "org_guid", "space_guid", "space_name", "service_instance_guid", "service_instance_name", "service_instance_type", "service_plan_guid", "service_plan_name", "service_guid", "service_label", "service_broker_name", "service_broker_guid"}
    serviceUsageEventColumnsWithDefault    = []string{"id"}
    serviceUsageEventPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceUsageEventType                 = reflect.TypeOf(&ServiceUsageEvent{})
    serviceUsageEventMapping              = queries.MakeStructMapping(serviceUsageEventType)
    serviceUsageEventPrimaryKeyMapping, _ = queries.BindMapping(serviceUsageEventType, serviceUsageEventMapping, serviceUsageEventPrimaryKeyColumns)
    serviceUsageEventInsertCacheMut       sync.RWMutex
    serviceUsageEventInsertCache          = make(map[string]insertCache)
    serviceUsageEventUpdateCacheMut       sync.RWMutex
    serviceUsageEventUpdateCache          = make(map[string]updateCache)
    serviceUsageEventUpsertCacheMut       sync.RWMutex
    serviceUsageEventUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    serviceAllColumns            = []string{"id", "guid", "created_at", "updated_at", "label", "description", "info_url", "acls", "timeout", "active", "extra", "unique_id", "bindable", "tags", "documentation_url", "service_broker_id", "long_description", "requires", "purging", "plan_updateable", "bindings_retrievable", "instances_retrievable", "allow_context_updates"}
    serviceColumnsWithoutDefault = []string{"guid", "updated_at", "label", "description", "info_url", "acls", "timeout", "extra", "unique_id", "bindable", "tags", "documentation_url", "service_broker_id", "long_description", "requires"}
    serviceColumnsWithDefault    = []string{"id", "created_at", "active", "purging", "plan_updateable", "bindings_retrievable", "instances_retrievable", "allow_context_updates"}
    servicePrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    serviceType                 = reflect.TypeOf(&Service{})
    serviceMapping              = queries.MakeStructMapping(serviceType)
    servicePrimaryKeyMapping, _ = queries.BindMapping(serviceType, serviceMapping, servicePrimaryKeyColumns)
    serviceInsertCacheMut       sync.RWMutex
    serviceInsertCache          = make(map[string]insertCache)
    serviceUpdateCacheMut       sync.RWMutex
    serviceUpdateCache          = make(map[string]updateCache)
    serviceUpsertCacheMut       sync.RWMutex
    serviceUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    sidecarProcessTypeAllColumns            = []string{"id", "guid", "created_at", "updated_at", "type", "sidecar_guid", "app_guid"}
    sidecarProcessTypeColumnsWithoutDefault = []string{"guid", "updated_at", "type", "sidecar_guid", "app_guid"}
    sidecarProcessTypeColumnsWithDefault    = []string{"id", "created_at"}
    sidecarProcessTypePrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    sidecarProcessTypeType                 = reflect.TypeOf(&SidecarProcessType{})
    sidecarProcessTypeMapping              = queries.MakeStructMapping(sidecarProcessTypeType)
    sidecarProcessTypePrimaryKeyMapping, _ = queries.BindMapping(sidecarProcessTypeType, sidecarProcessTypeMapping, sidecarProcessTypePrimaryKeyColumns)
    sidecarProcessTypeInsertCacheMut       sync.RWMutex
    sidecarProcessTypeInsertCache          = make(map[string]insertCache)
    sidecarProcessTypeUpdateCacheMut       sync.RWMutex
    sidecarProcessTypeUpdateCache          = make(map[string]updateCache)
    sidecarProcessTypeUpsertCacheMut       sync.RWMutex
    sidecarProcessTypeUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    sidecarAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "command", "app_guid", "memory", "origin"}
    sidecarColumnsWithoutDefault = []string{"guid", "updated_at", "name", "command", "app_guid", "memory"}
    sidecarColumnsWithDefault    = []string{"id", "created_at", "origin"}
    sidecarPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    sidecarType                 = reflect.TypeOf(&Sidecar{})
    sidecarMapping              = queries.MakeStructMapping(sidecarType)
    sidecarPrimaryKeyMapping, _ = queries.BindMapping(sidecarType, sidecarMapping, sidecarPrimaryKeyColumns)
    sidecarInsertCacheMut       sync.RWMutex
    sidecarInsertCache          = make(map[string]insertCache)
    sidecarUpdateCacheMut       sync.RWMutex
    sidecarUpdateCache          = make(map[string]updateCache)
    sidecarUpsertCacheMut       sync.RWMutex
    sidecarUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    spaceAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    spaceAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    spaceAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    spaceAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    spaceAnnotationType                 = reflect.TypeOf(&SpaceAnnotation{})
    spaceAnnotationMapping              = queries.MakeStructMapping(spaceAnnotationType)
    spaceAnnotationPrimaryKeyMapping, _ = queries.BindMapping(spaceAnnotationType, spaceAnnotationMapping, spaceAnnotationPrimaryKeyColumns)
    spaceAnnotationInsertCacheMut       sync.RWMutex
    spaceAnnotationInsertCache          = make(map[string]insertCache)
    spaceAnnotationUpdateCacheMut       sync.RWMutex
    spaceAnnotationUpdateCache          = make(map[string]updateCache)
    spaceAnnotationUpsertCacheMut       sync.RWMutex
    spaceAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    spaceLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    spaceLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    spaceLabelColumnsWithDefault    = []string{"id", "created_at"}
    spaceLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    spaceLabelType                 = reflect.TypeOf(&SpaceLabel{})
    spaceLabelMapping              = queries.MakeStructMapping(spaceLabelType)
    spaceLabelPrimaryKeyMapping, _ = queries.BindMapping(spaceLabelType, spaceLabelMapping, spaceLabelPrimaryKeyColumns)
    spaceLabelInsertCacheMut       sync.RWMutex
    spaceLabelInsertCache          = make(map[string]insertCache)
    spaceLabelUpdateCacheMut       sync.RWMutex
    spaceLabelUpdateCache          = make(map[string]updateCache)
    spaceLabelUpsertCacheMut       sync.RWMutex
    spaceLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    spaceQuotaDefinitionAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "non_basic_services_allowed", "total_services", "memory_limit", "total_routes", "instance_memory_limit", "organization_id", "app_instance_limit", "app_task_limit", "total_service_keys", "total_reserved_route_ports"}
    spaceQuotaDefinitionColumnsWithoutDefault = []string{"guid", "updated_at", "name", "non_basic_services_allowed", "total_services", "memory_limit", "total_routes", "organization_id"}
    spaceQuotaDefinitionColumnsWithDefault    = []string{"id", "created_at", "instance_memory_limit", "app_instance_limit", "app_task_limit", "total_service_keys", "total_reserved_route_ports"}
    spaceQuotaDefinitionPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    spaceQuotaDefinitionType                 = reflect.TypeOf(&SpaceQuotaDefinition{})
    spaceQuotaDefinitionMapping              = queries.MakeStructMapping(spaceQuotaDefinitionType)
    spaceQuotaDefinitionPrimaryKeyMapping, _ = queries.BindMapping(spaceQuotaDefinitionType, spaceQuotaDefinitionMapping, spaceQuotaDefinitionPrimaryKeyColumns)
    spaceQuotaDefinitionInsertCacheMut       sync.RWMutex
    spaceQuotaDefinitionInsertCache          = make(map[string]insertCache)
    spaceQuotaDefinitionUpdateCacheMut       sync.RWMutex
    spaceQuotaDefinitionUpdateCache          = make(map[string]updateCache)
    spaceQuotaDefinitionUpsertCacheMut       sync.RWMutex
    spaceQuotaDefinitionUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    spaceAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "organization_id", "space_quota_definition_id", "allow_ssh", "isolation_segment_guid"}
    spaceColumnsWithoutDefault = []string{"guid", "updated_at", "name", "organization_id", "space_quota_definition_id", "isolation_segment_guid"}
    spaceColumnsWithDefault    = []string{"id", "created_at", "allow_ssh"}
    spacePrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    spaceType                 = reflect.TypeOf(&Space{})
    spaceMapping              = queries.MakeStructMapping(spaceType)
    spacePrimaryKeyMapping, _ = queries.BindMapping(spaceType, spaceMapping, spacePrimaryKeyColumns)
    spaceInsertCacheMut       sync.RWMutex
    spaceInsertCache          = make(map[string]insertCache)
    spaceUpdateCacheMut       sync.RWMutex
    spaceUpdateCache          = make(map[string]updateCache)
    spaceUpsertCacheMut       sync.RWMutex
    spaceUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    spacesApplicationSupporterAllColumns            = []string{"spaces_application_supporters_pk", "role_guid", "space_id", "user_id", "created_at", "updated_at"}
    spacesApplicationSupporterColumnsWithoutDefault = []string{"role_guid", "space_id", "user_id"}
    spacesApplicationSupporterColumnsWithDefault    = []string{"spaces_application_supporters_pk", "created_at", "updated_at"}
    spacesApplicationSupporterPrimaryKeyColumns     = []string{"spaces_application_supporters_pk"}
)

Cache for insert\, update and upsert

var (
    spacesApplicationSupporterType                 = reflect.TypeOf(&SpacesApplicationSupporter{})
    spacesApplicationSupporterMapping              = queries.MakeStructMapping(spacesApplicationSupporterType)
    spacesApplicationSupporterPrimaryKeyMapping, _ = queries.BindMapping(spacesApplicationSupporterType, spacesApplicationSupporterMapping, spacesApplicationSupporterPrimaryKeyColumns)
    spacesApplicationSupporterInsertCacheMut       sync.RWMutex
    spacesApplicationSupporterInsertCache          = make(map[string]insertCache)
    spacesApplicationSupporterUpdateCacheMut       sync.RWMutex
    spacesApplicationSupporterUpdateCache          = make(map[string]updateCache)
    spacesApplicationSupporterUpsertCacheMut       sync.RWMutex
    spacesApplicationSupporterUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    spacesAuditorAllColumns            = []string{"space_id", "user_id", "spaces_auditors_pk", "role_guid", "created_at", "updated_at"}
    spacesAuditorColumnsWithoutDefault = []string{"space_id", "user_id", "role_guid"}
    spacesAuditorColumnsWithDefault    = []string{"spaces_auditors_pk", "created_at", "updated_at"}
    spacesAuditorPrimaryKeyColumns     = []string{"spaces_auditors_pk"}
)

Cache for insert\, update and upsert

var (
    spacesAuditorType                 = reflect.TypeOf(&SpacesAuditor{})
    spacesAuditorMapping              = queries.MakeStructMapping(spacesAuditorType)
    spacesAuditorPrimaryKeyMapping, _ = queries.BindMapping(spacesAuditorType, spacesAuditorMapping, spacesAuditorPrimaryKeyColumns)
    spacesAuditorInsertCacheMut       sync.RWMutex
    spacesAuditorInsertCache          = make(map[string]insertCache)
    spacesAuditorUpdateCacheMut       sync.RWMutex
    spacesAuditorUpdateCache          = make(map[string]updateCache)
    spacesAuditorUpsertCacheMut       sync.RWMutex
    spacesAuditorUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    spacesDeveloperAllColumns            = []string{"space_id", "user_id", "spaces_developers_pk", "role_guid", "created_at", "updated_at"}
    spacesDeveloperColumnsWithoutDefault = []string{"space_id", "user_id", "role_guid"}
    spacesDeveloperColumnsWithDefault    = []string{"spaces_developers_pk", "created_at", "updated_at"}
    spacesDeveloperPrimaryKeyColumns     = []string{"spaces_developers_pk"}
)

Cache for insert\, update and upsert

var (
    spacesDeveloperType                 = reflect.TypeOf(&SpacesDeveloper{})
    spacesDeveloperMapping              = queries.MakeStructMapping(spacesDeveloperType)
    spacesDeveloperPrimaryKeyMapping, _ = queries.BindMapping(spacesDeveloperType, spacesDeveloperMapping, spacesDeveloperPrimaryKeyColumns)
    spacesDeveloperInsertCacheMut       sync.RWMutex
    spacesDeveloperInsertCache          = make(map[string]insertCache)
    spacesDeveloperUpdateCacheMut       sync.RWMutex
    spacesDeveloperUpdateCache          = make(map[string]updateCache)
    spacesDeveloperUpsertCacheMut       sync.RWMutex
    spacesDeveloperUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    spacesManagerAllColumns            = []string{"space_id", "user_id", "spaces_managers_pk", "role_guid", "created_at", "updated_at"}
    spacesManagerColumnsWithoutDefault = []string{"space_id", "user_id", "role_guid"}
    spacesManagerColumnsWithDefault    = []string{"spaces_managers_pk", "created_at", "updated_at"}
    spacesManagerPrimaryKeyColumns     = []string{"spaces_managers_pk"}
)

Cache for insert\, update and upsert

var (
    spacesManagerType                 = reflect.TypeOf(&SpacesManager{})
    spacesManagerMapping              = queries.MakeStructMapping(spacesManagerType)
    spacesManagerPrimaryKeyMapping, _ = queries.BindMapping(spacesManagerType, spacesManagerMapping, spacesManagerPrimaryKeyColumns)
    spacesManagerInsertCacheMut       sync.RWMutex
    spacesManagerInsertCache          = make(map[string]insertCache)
    spacesManagerUpdateCacheMut       sync.RWMutex
    spacesManagerUpdateCache          = make(map[string]updateCache)
    spacesManagerUpsertCacheMut       sync.RWMutex
    spacesManagerUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    stackAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    stackAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    stackAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    stackAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    stackAnnotationType                 = reflect.TypeOf(&StackAnnotation{})
    stackAnnotationMapping              = queries.MakeStructMapping(stackAnnotationType)
    stackAnnotationPrimaryKeyMapping, _ = queries.BindMapping(stackAnnotationType, stackAnnotationMapping, stackAnnotationPrimaryKeyColumns)
    stackAnnotationInsertCacheMut       sync.RWMutex
    stackAnnotationInsertCache          = make(map[string]insertCache)
    stackAnnotationUpdateCacheMut       sync.RWMutex
    stackAnnotationUpdateCache          = make(map[string]updateCache)
    stackAnnotationUpsertCacheMut       sync.RWMutex
    stackAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    stackLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    stackLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    stackLabelColumnsWithDefault    = []string{"id", "created_at"}
    stackLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    stackLabelType                 = reflect.TypeOf(&StackLabel{})
    stackLabelMapping              = queries.MakeStructMapping(stackLabelType)
    stackLabelPrimaryKeyMapping, _ = queries.BindMapping(stackLabelType, stackLabelMapping, stackLabelPrimaryKeyColumns)
    stackLabelInsertCacheMut       sync.RWMutex
    stackLabelInsertCache          = make(map[string]insertCache)
    stackLabelUpdateCacheMut       sync.RWMutex
    stackLabelUpdateCache          = make(map[string]updateCache)
    stackLabelUpsertCacheMut       sync.RWMutex
    stackLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    stackAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "description"}
    stackColumnsWithoutDefault = []string{"guid", "updated_at", "name", "description"}
    stackColumnsWithDefault    = []string{"id", "created_at"}
    stackPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    stackType                 = reflect.TypeOf(&Stack{})
    stackMapping              = queries.MakeStructMapping(stackType)
    stackPrimaryKeyMapping, _ = queries.BindMapping(stackType, stackMapping, stackPrimaryKeyColumns)
    stackInsertCacheMut       sync.RWMutex
    stackInsertCache          = make(map[string]insertCache)
    stackUpdateCacheMut       sync.RWMutex
    stackUpdateCache          = make(map[string]updateCache)
    stackUpsertCacheMut       sync.RWMutex
    stackUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    stagingSecurityGroupsSpaceAllColumns            = []string{"staging_security_group_id", "staging_space_id", "staging_security_groups_spaces_pk"}
    stagingSecurityGroupsSpaceColumnsWithoutDefault = []string{"staging_security_group_id", "staging_space_id"}
    stagingSecurityGroupsSpaceColumnsWithDefault    = []string{"staging_security_groups_spaces_pk"}
    stagingSecurityGroupsSpacePrimaryKeyColumns     = []string{"staging_security_groups_spaces_pk"}
)

Cache for insert\, update and upsert

var (
    stagingSecurityGroupsSpaceType                 = reflect.TypeOf(&StagingSecurityGroupsSpace{})
    stagingSecurityGroupsSpaceMapping              = queries.MakeStructMapping(stagingSecurityGroupsSpaceType)
    stagingSecurityGroupsSpacePrimaryKeyMapping, _ = queries.BindMapping(stagingSecurityGroupsSpaceType, stagingSecurityGroupsSpaceMapping, stagingSecurityGroupsSpacePrimaryKeyColumns)
    stagingSecurityGroupsSpaceInsertCacheMut       sync.RWMutex
    stagingSecurityGroupsSpaceInsertCache          = make(map[string]insertCache)
    stagingSecurityGroupsSpaceUpdateCacheMut       sync.RWMutex
    stagingSecurityGroupsSpaceUpdateCache          = make(map[string]updateCache)
    stagingSecurityGroupsSpaceUpsertCacheMut       sync.RWMutex
    stagingSecurityGroupsSpaceUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    taskAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    taskAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    taskAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    taskAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    taskAnnotationType                 = reflect.TypeOf(&TaskAnnotation{})
    taskAnnotationMapping              = queries.MakeStructMapping(taskAnnotationType)
    taskAnnotationPrimaryKeyMapping, _ = queries.BindMapping(taskAnnotationType, taskAnnotationMapping, taskAnnotationPrimaryKeyColumns)
    taskAnnotationInsertCacheMut       sync.RWMutex
    taskAnnotationInsertCache          = make(map[string]insertCache)
    taskAnnotationUpdateCacheMut       sync.RWMutex
    taskAnnotationUpdateCache          = make(map[string]updateCache)
    taskAnnotationUpsertCacheMut       sync.RWMutex
    taskAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    taskLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    taskLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    taskLabelColumnsWithDefault    = []string{"id", "created_at"}
    taskLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    taskLabelType                 = reflect.TypeOf(&TaskLabel{})
    taskLabelMapping              = queries.MakeStructMapping(taskLabelType)
    taskLabelPrimaryKeyMapping, _ = queries.BindMapping(taskLabelType, taskLabelMapping, taskLabelPrimaryKeyColumns)
    taskLabelInsertCacheMut       sync.RWMutex
    taskLabelInsertCache          = make(map[string]insertCache)
    taskLabelUpdateCacheMut       sync.RWMutex
    taskLabelUpdateCache          = make(map[string]updateCache)
    taskLabelUpsertCacheMut       sync.RWMutex
    taskLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    taskAllColumns            = []string{"id", "guid", "created_at", "updated_at", "name", "command", "state", "memory_in_mb", "encrypted_environment_variables", "salt", "failure_reason", "app_guid", "droplet_guid", "sequence_id", "disk_in_mb", "encryption_key_label", "encryption_iterations"}
    taskColumnsWithoutDefault = []string{"guid", "updated_at", "name", "command", "state", "memory_in_mb", "encrypted_environment_variables", "salt", "failure_reason", "app_guid", "droplet_guid", "sequence_id", "disk_in_mb", "encryption_key_label"}
    taskColumnsWithDefault    = []string{"id", "created_at", "encryption_iterations"}
    taskPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    taskType                 = reflect.TypeOf(&Task{})
    taskMapping              = queries.MakeStructMapping(taskType)
    taskPrimaryKeyMapping, _ = queries.BindMapping(taskType, taskMapping, taskPrimaryKeyColumns)
    taskInsertCacheMut       sync.RWMutex
    taskInsertCache          = make(map[string]insertCache)
    taskUpdateCacheMut       sync.RWMutex
    taskUpdateCache          = make(map[string]updateCache)
    taskUpsertCacheMut       sync.RWMutex
    taskUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    userAnnotationAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    userAnnotationColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key", "value"}
    userAnnotationColumnsWithDefault    = []string{"id", "created_at"}
    userAnnotationPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    userAnnotationType                 = reflect.TypeOf(&UserAnnotation{})
    userAnnotationMapping              = queries.MakeStructMapping(userAnnotationType)
    userAnnotationPrimaryKeyMapping, _ = queries.BindMapping(userAnnotationType, userAnnotationMapping, userAnnotationPrimaryKeyColumns)
    userAnnotationInsertCacheMut       sync.RWMutex
    userAnnotationInsertCache          = make(map[string]insertCache)
    userAnnotationUpdateCacheMut       sync.RWMutex
    userAnnotationUpdateCache          = make(map[string]updateCache)
    userAnnotationUpsertCacheMut       sync.RWMutex
    userAnnotationUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    userLabelAllColumns            = []string{"id", "guid", "created_at", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    userLabelColumnsWithoutDefault = []string{"guid", "updated_at", "resource_guid", "key_prefix", "key_name", "value"}
    userLabelColumnsWithDefault    = []string{"id", "created_at"}
    userLabelPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    userLabelType                 = reflect.TypeOf(&UserLabel{})
    userLabelMapping              = queries.MakeStructMapping(userLabelType)
    userLabelPrimaryKeyMapping, _ = queries.BindMapping(userLabelType, userLabelMapping, userLabelPrimaryKeyColumns)
    userLabelInsertCacheMut       sync.RWMutex
    userLabelInsertCache          = make(map[string]insertCache)
    userLabelUpdateCacheMut       sync.RWMutex
    userLabelUpdateCache          = make(map[string]updateCache)
    userLabelUpsertCacheMut       sync.RWMutex
    userLabelUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var (
    userAllColumns            = []string{"id", "guid", "created_at", "updated_at", "default_space_id", "admin", "active", "is_oauth_client"}
    userColumnsWithoutDefault = []string{"guid", "updated_at", "default_space_id", "is_oauth_client"}
    userColumnsWithDefault    = []string{"id", "created_at", "admin", "active"}
    userPrimaryKeyColumns     = []string{"id"}
)

Cache for insert\, update and upsert

var (
    userType                 = reflect.TypeOf(&User{})
    userMapping              = queries.MakeStructMapping(userType)
    userPrimaryKeyMapping, _ = queries.BindMapping(userType, userMapping, userPrimaryKeyColumns)
    userInsertCacheMut       sync.RWMutex
    userInsertCache          = make(map[string]insertCache)
    userUpdateCacheMut       sync.RWMutex
    userUpdateCache          = make(map[string]updateCache)
    userUpsertCacheMut       sync.RWMutex
    userUpsertCache          = make(map[string]insertCache)
)
var (
    // Force time package dependency for automated UpdatedAt/CreatedAt.
    _   = time.Second
    // Force qmhelper dependency for where clause generation (which doesn't
    // always happen)
    _   = qmhelper.Where
)
var AppAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

AppAnnotationRels is where relationship names are stored.

var AppAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var AppAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "app_annotations.id",
    GUID:         "app_annotations.guid",
    CreatedAt:    "app_annotations.created_at",
    UpdatedAt:    "app_annotations.updated_at",
    ResourceGUID: "app_annotations.resource_guid",
    KeyPrefix:    "app_annotations.key_prefix",
    Key:          "app_annotations.key",
    Value:        "app_annotations.value",
}
var AppAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"app_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"app_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"app_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"app_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"app_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"app_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"app_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"app_annotations\".\"value\""},
}
var AppColumns = struct {
    ID                            string
    GUID                          string
    CreatedAt                     string
    UpdatedAt                     string
    SpaceGUID                     string
    Name                          string
    DropletGUID                   string
    DesiredState                  string
    EncryptedEnvironmentVariables string
    Salt                          string
    MaxTaskSequenceID             string
    BuildpackCacheSha256Checksum  string
    EnableSSH                     string
    EncryptionKeyLabel            string
    EncryptionIterations          string
    RevisionsEnabled              string
}{
    ID:                            "id",
    GUID:                          "guid",
    CreatedAt:                     "created_at",
    UpdatedAt:                     "updated_at",
    SpaceGUID:                     "space_guid",
    Name:                          "name",
    DropletGUID:                   "droplet_guid",
    DesiredState:                  "desired_state",
    EncryptedEnvironmentVariables: "encrypted_environment_variables",
    Salt:                          "salt",
    MaxTaskSequenceID:             "max_task_sequence_id",
    BuildpackCacheSha256Checksum:  "buildpack_cache_sha256_checksum",
    EnableSSH:                     "enable_ssh",
    EncryptionKeyLabel:            "encryption_key_label",
    EncryptionIterations:          "encryption_iterations",
    RevisionsEnabled:              "revisions_enabled",
}
var AppEventColumns = struct {
    ID              string
    GUID            string
    CreatedAt       string
    UpdatedAt       string
    AppID           string
    InstanceGUID    string
    InstanceIndex   string
    ExitStatus      string
    Timestamp       string
    ExitDescription string
}{
    ID:              "id",
    GUID:            "guid",
    CreatedAt:       "created_at",
    UpdatedAt:       "updated_at",
    AppID:           "app_id",
    InstanceGUID:    "instance_guid",
    InstanceIndex:   "instance_index",
    ExitStatus:      "exit_status",
    Timestamp:       "timestamp",
    ExitDescription: "exit_description",
}

AppEventRels is where relationship names are stored.

var AppEventRels = struct {
    App string
}{
    App: "App",
}
var AppEventTableColumns = struct {
    ID              string
    GUID            string
    CreatedAt       string
    UpdatedAt       string
    AppID           string
    InstanceGUID    string
    InstanceIndex   string
    ExitStatus      string
    Timestamp       string
    ExitDescription string
}{
    ID:              "app_events.id",
    GUID:            "app_events.guid",
    CreatedAt:       "app_events.created_at",
    UpdatedAt:       "app_events.updated_at",
    AppID:           "app_events.app_id",
    InstanceGUID:    "app_events.instance_guid",
    InstanceIndex:   "app_events.instance_index",
    ExitStatus:      "app_events.exit_status",
    Timestamp:       "app_events.timestamp",
    ExitDescription: "app_events.exit_description",
}
var AppEventWhere = struct {
    ID              whereHelperint
    GUID            whereHelperstring
    CreatedAt       whereHelpertime_Time
    UpdatedAt       whereHelpernull_Time
    AppID           whereHelperint
    InstanceGUID    whereHelperstring
    InstanceIndex   whereHelperint
    ExitStatus      whereHelperint
    Timestamp       whereHelpertime_Time
    ExitDescription whereHelpernull_String
}{
    ID:              whereHelperint{field: "\"app_events\".\"id\""},
    GUID:            whereHelperstring{field: "\"app_events\".\"guid\""},
    CreatedAt:       whereHelpertime_Time{field: "\"app_events\".\"created_at\""},
    UpdatedAt:       whereHelpernull_Time{field: "\"app_events\".\"updated_at\""},
    AppID:           whereHelperint{field: "\"app_events\".\"app_id\""},
    InstanceGUID:    whereHelperstring{field: "\"app_events\".\"instance_guid\""},
    InstanceIndex:   whereHelperint{field: "\"app_events\".\"instance_index\""},
    ExitStatus:      whereHelperint{field: "\"app_events\".\"exit_status\""},
    Timestamp:       whereHelpertime_Time{field: "\"app_events\".\"timestamp\""},
    ExitDescription: whereHelpernull_String{field: "\"app_events\".\"exit_description\""},
}
var AppLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

AppLabelRels is where relationship names are stored.

var AppLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var AppLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "app_labels.id",
    GUID:         "app_labels.guid",
    CreatedAt:    "app_labels.created_at",
    UpdatedAt:    "app_labels.updated_at",
    ResourceGUID: "app_labels.resource_guid",
    KeyPrefix:    "app_labels.key_prefix",
    KeyName:      "app_labels.key_name",
    Value:        "app_labels.value",
}
var AppLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"app_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"app_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"app_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"app_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"app_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"app_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"app_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"app_labels\".\"value\""},
}

AppRels is where relationship names are stored.

var AppRels = struct {
    Space                  string
    ResourceAppAnnotations string
    ResourceAppLabels      string
    Builds                 string
    Deployments            string
    Droplets               string
    KpackLifecycleData     string
    Packages               string
    Processes              string
    Revisions              string
    RouteMappings          string
    ServiceBindings        string
    Sidecars               string
    Tasks                  string
}{
    Space:                  "Space",
    ResourceAppAnnotations: "ResourceAppAnnotations",
    ResourceAppLabels:      "ResourceAppLabels",
    Builds:                 "Builds",
    Deployments:            "Deployments",
    Droplets:               "Droplets",
    KpackLifecycleData:     "KpackLifecycleData",
    Packages:               "Packages",
    Processes:              "Processes",
    Revisions:              "Revisions",
    RouteMappings:          "RouteMappings",
    ServiceBindings:        "ServiceBindings",
    Sidecars:               "Sidecars",
    Tasks:                  "Tasks",
}
var AppTableColumns = struct {
    ID                            string
    GUID                          string
    CreatedAt                     string
    UpdatedAt                     string
    SpaceGUID                     string
    Name                          string
    DropletGUID                   string
    DesiredState                  string
    EncryptedEnvironmentVariables string
    Salt                          string
    MaxTaskSequenceID             string
    BuildpackCacheSha256Checksum  string
    EnableSSH                     string
    EncryptionKeyLabel            string
    EncryptionIterations          string
    RevisionsEnabled              string
}{
    ID:                            "apps.id",
    GUID:                          "apps.guid",
    CreatedAt:                     "apps.created_at",
    UpdatedAt:                     "apps.updated_at",
    SpaceGUID:                     "apps.space_guid",
    Name:                          "apps.name",
    DropletGUID:                   "apps.droplet_guid",
    DesiredState:                  "apps.desired_state",
    EncryptedEnvironmentVariables: "apps.encrypted_environment_variables",
    Salt:                          "apps.salt",
    MaxTaskSequenceID:             "apps.max_task_sequence_id",
    BuildpackCacheSha256Checksum:  "apps.buildpack_cache_sha256_checksum",
    EnableSSH:                     "apps.enable_ssh",
    EncryptionKeyLabel:            "apps.encryption_key_label",
    EncryptionIterations:          "apps.encryption_iterations",
    RevisionsEnabled:              "apps.revisions_enabled",
}
var AppUsageEventColumns = struct {
    ID                            string
    GUID                          string
    CreatedAt                     string
    InstanceCount                 string
    MemoryInMBPerInstance         string
    State                         string
    AppGUID                       string
    AppName                       string
    SpaceGUID                     string
    SpaceName                     string
    OrgGUID                       string
    BuildpackGUID                 string
    BuildpackName                 string
    PackageState                  string
    ParentAppName                 string
    ParentAppGUID                 string
    ProcessType                   string
    TaskGUID                      string
    TaskName                      string
    PackageGUID                   string
    PreviousState                 string
    PreviousPackageState          string
    PreviousMemoryInMBPerInstance string
    PreviousInstanceCount         string
}{
    ID:                            "id",
    GUID:                          "guid",
    CreatedAt:                     "created_at",
    InstanceCount:                 "instance_count",
    MemoryInMBPerInstance:         "memory_in_mb_per_instance",
    State:                         "state",
    AppGUID:                       "app_guid",
    AppName:                       "app_name",
    SpaceGUID:                     "space_guid",
    SpaceName:                     "space_name",
    OrgGUID:                       "org_guid",
    BuildpackGUID:                 "buildpack_guid",
    BuildpackName:                 "buildpack_name",
    PackageState:                  "package_state",
    ParentAppName:                 "parent_app_name",
    ParentAppGUID:                 "parent_app_guid",
    ProcessType:                   "process_type",
    TaskGUID:                      "task_guid",
    TaskName:                      "task_name",
    PackageGUID:                   "package_guid",
    PreviousState:                 "previous_state",
    PreviousPackageState:          "previous_package_state",
    PreviousMemoryInMBPerInstance: "previous_memory_in_mb_per_instance",
    PreviousInstanceCount:         "previous_instance_count",
}

AppUsageEventRels is where relationship names are stored.

var AppUsageEventRels = struct {
}{}
var AppUsageEventTableColumns = struct {
    ID                            string
    GUID                          string
    CreatedAt                     string
    InstanceCount                 string
    MemoryInMBPerInstance         string
    State                         string
    AppGUID                       string
    AppName                       string
    SpaceGUID                     string
    SpaceName                     string
    OrgGUID                       string
    BuildpackGUID                 string
    BuildpackName                 string
    PackageState                  string
    ParentAppName                 string
    ParentAppGUID                 string
    ProcessType                   string
    TaskGUID                      string
    TaskName                      string
    PackageGUID                   string
    PreviousState                 string
    PreviousPackageState          string
    PreviousMemoryInMBPerInstance string
    PreviousInstanceCount         string
}{
    ID:                            "app_usage_events.id",
    GUID:                          "app_usage_events.guid",
    CreatedAt:                     "app_usage_events.created_at",
    InstanceCount:                 "app_usage_events.instance_count",
    MemoryInMBPerInstance:         "app_usage_events.memory_in_mb_per_instance",
    State:                         "app_usage_events.state",
    AppGUID:                       "app_usage_events.app_guid",
    AppName:                       "app_usage_events.app_name",
    SpaceGUID:                     "app_usage_events.space_guid",
    SpaceName:                     "app_usage_events.space_name",
    OrgGUID:                       "app_usage_events.org_guid",
    BuildpackGUID:                 "app_usage_events.buildpack_guid",
    BuildpackName:                 "app_usage_events.buildpack_name",
    PackageState:                  "app_usage_events.package_state",
    ParentAppName:                 "app_usage_events.parent_app_name",
    ParentAppGUID:                 "app_usage_events.parent_app_guid",
    ProcessType:                   "app_usage_events.process_type",
    TaskGUID:                      "app_usage_events.task_guid",
    TaskName:                      "app_usage_events.task_name",
    PackageGUID:                   "app_usage_events.package_guid",
    PreviousState:                 "app_usage_events.previous_state",
    PreviousPackageState:          "app_usage_events.previous_package_state",
    PreviousMemoryInMBPerInstance: "app_usage_events.previous_memory_in_mb_per_instance",
    PreviousInstanceCount:         "app_usage_events.previous_instance_count",
}
var AppUsageEventWhere = struct {
    ID                            whereHelperint
    GUID                          whereHelperstring
    CreatedAt                     whereHelpertime_Time
    InstanceCount                 whereHelperint
    MemoryInMBPerInstance         whereHelperint
    State                         whereHelperstring
    AppGUID                       whereHelperstring
    AppName                       whereHelperstring
    SpaceGUID                     whereHelperstring
    SpaceName                     whereHelperstring
    OrgGUID                       whereHelperstring
    BuildpackGUID                 whereHelpernull_String
    BuildpackName                 whereHelpernull_String
    PackageState                  whereHelpernull_String
    ParentAppName                 whereHelpernull_String
    ParentAppGUID                 whereHelpernull_String
    ProcessType                   whereHelpernull_String
    TaskGUID                      whereHelpernull_String
    TaskName                      whereHelpernull_String
    PackageGUID                   whereHelpernull_String
    PreviousState                 whereHelpernull_String
    PreviousPackageState          whereHelpernull_String
    PreviousMemoryInMBPerInstance whereHelpernull_Int
    PreviousInstanceCount         whereHelpernull_Int
}{
    ID:                            whereHelperint{field: "\"app_usage_events\".\"id\""},
    GUID:                          whereHelperstring{field: "\"app_usage_events\".\"guid\""},
    CreatedAt:                     whereHelpertime_Time{field: "\"app_usage_events\".\"created_at\""},
    InstanceCount:                 whereHelperint{field: "\"app_usage_events\".\"instance_count\""},
    MemoryInMBPerInstance:         whereHelperint{field: "\"app_usage_events\".\"memory_in_mb_per_instance\""},
    State:                         whereHelperstring{field: "\"app_usage_events\".\"state\""},
    AppGUID:                       whereHelperstring{field: "\"app_usage_events\".\"app_guid\""},
    AppName:                       whereHelperstring{field: "\"app_usage_events\".\"app_name\""},
    SpaceGUID:                     whereHelperstring{field: "\"app_usage_events\".\"space_guid\""},
    SpaceName:                     whereHelperstring{field: "\"app_usage_events\".\"space_name\""},
    OrgGUID:                       whereHelperstring{field: "\"app_usage_events\".\"org_guid\""},
    BuildpackGUID:                 whereHelpernull_String{field: "\"app_usage_events\".\"buildpack_guid\""},
    BuildpackName:                 whereHelpernull_String{field: "\"app_usage_events\".\"buildpack_name\""},
    PackageState:                  whereHelpernull_String{field: "\"app_usage_events\".\"package_state\""},
    ParentAppName:                 whereHelpernull_String{field: "\"app_usage_events\".\"parent_app_name\""},
    ParentAppGUID:                 whereHelpernull_String{field: "\"app_usage_events\".\"parent_app_guid\""},
    ProcessType:                   whereHelpernull_String{field: "\"app_usage_events\".\"process_type\""},
    TaskGUID:                      whereHelpernull_String{field: "\"app_usage_events\".\"task_guid\""},
    TaskName:                      whereHelpernull_String{field: "\"app_usage_events\".\"task_name\""},
    PackageGUID:                   whereHelpernull_String{field: "\"app_usage_events\".\"package_guid\""},
    PreviousState:                 whereHelpernull_String{field: "\"app_usage_events\".\"previous_state\""},
    PreviousPackageState:          whereHelpernull_String{field: "\"app_usage_events\".\"previous_package_state\""},
    PreviousMemoryInMBPerInstance: whereHelpernull_Int{field: "\"app_usage_events\".\"previous_memory_in_mb_per_instance\""},
    PreviousInstanceCount:         whereHelpernull_Int{field: "\"app_usage_events\".\"previous_instance_count\""},
}
var AppWhere = struct {
    ID                            whereHelperint
    GUID                          whereHelperstring
    CreatedAt                     whereHelpertime_Time
    UpdatedAt                     whereHelpernull_Time
    SpaceGUID                     whereHelpernull_String
    Name                          whereHelpernull_String
    DropletGUID                   whereHelpernull_String
    DesiredState                  whereHelpernull_String
    EncryptedEnvironmentVariables whereHelpernull_String
    Salt                          whereHelpernull_String
    MaxTaskSequenceID             whereHelpernull_Int
    BuildpackCacheSha256Checksum  whereHelpernull_String
    EnableSSH                     whereHelpernull_Bool
    EncryptionKeyLabel            whereHelpernull_String
    EncryptionIterations          whereHelperint
    RevisionsEnabled              whereHelpernull_Bool
}{
    ID:                            whereHelperint{field: "\"apps\".\"id\""},
    GUID:                          whereHelperstring{field: "\"apps\".\"guid\""},
    CreatedAt:                     whereHelpertime_Time{field: "\"apps\".\"created_at\""},
    UpdatedAt:                     whereHelpernull_Time{field: "\"apps\".\"updated_at\""},
    SpaceGUID:                     whereHelpernull_String{field: "\"apps\".\"space_guid\""},
    Name:                          whereHelpernull_String{field: "\"apps\".\"name\""},
    DropletGUID:                   whereHelpernull_String{field: "\"apps\".\"droplet_guid\""},
    DesiredState:                  whereHelpernull_String{field: "\"apps\".\"desired_state\""},
    EncryptedEnvironmentVariables: whereHelpernull_String{field: "\"apps\".\"encrypted_environment_variables\""},
    Salt:                          whereHelpernull_String{field: "\"apps\".\"salt\""},
    MaxTaskSequenceID:             whereHelpernull_Int{field: "\"apps\".\"max_task_sequence_id\""},
    BuildpackCacheSha256Checksum:  whereHelpernull_String{field: "\"apps\".\"buildpack_cache_sha256_checksum\""},
    EnableSSH:                     whereHelpernull_Bool{field: "\"apps\".\"enable_ssh\""},
    EncryptionKeyLabel:            whereHelpernull_String{field: "\"apps\".\"encryption_key_label\""},
    EncryptionIterations:          whereHelperint{field: "\"apps\".\"encryption_iterations\""},
    RevisionsEnabled:              whereHelpernull_Bool{field: "\"apps\".\"revisions_enabled\""},
}
var BuildAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

BuildAnnotationRels is where relationship names are stored.

var BuildAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var BuildAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "build_annotations.id",
    GUID:         "build_annotations.guid",
    CreatedAt:    "build_annotations.created_at",
    UpdatedAt:    "build_annotations.updated_at",
    ResourceGUID: "build_annotations.resource_guid",
    KeyPrefix:    "build_annotations.key_prefix",
    Key:          "build_annotations.key",
    Value:        "build_annotations.value",
}
var BuildAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"build_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"build_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"build_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"build_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"build_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"build_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"build_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"build_annotations\".\"value\""},
}
var BuildColumns = struct {
    ID                 string
    GUID               string
    CreatedAt          string
    UpdatedAt          string
    State              string
    PackageGUID        string
    ErrorDescription   string
    AppGUID            string
    ErrorID            string
    CreatedByUserGUID  string
    CreatedByUserName  string
    CreatedByUserEmail string
    StagingMemoryInMB  string
    StagingDiskInMB    string
}{
    ID:                 "id",
    GUID:               "guid",
    CreatedAt:          "created_at",
    UpdatedAt:          "updated_at",
    State:              "state",
    PackageGUID:        "package_guid",
    ErrorDescription:   "error_description",
    AppGUID:            "app_guid",
    ErrorID:            "error_id",
    CreatedByUserGUID:  "created_by_user_guid",
    CreatedByUserName:  "created_by_user_name",
    CreatedByUserEmail: "created_by_user_email",
    StagingMemoryInMB:  "staging_memory_in_mb",
    StagingDiskInMB:    "staging_disk_in_mb",
}
var BuildLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

BuildLabelRels is where relationship names are stored.

var BuildLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var BuildLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "build_labels.id",
    GUID:         "build_labels.guid",
    CreatedAt:    "build_labels.created_at",
    UpdatedAt:    "build_labels.updated_at",
    ResourceGUID: "build_labels.resource_guid",
    KeyPrefix:    "build_labels.key_prefix",
    KeyName:      "build_labels.key_name",
    Value:        "build_labels.value",
}
var BuildLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"build_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"build_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"build_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"build_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"build_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"build_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"build_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"build_labels\".\"value\""},
}

BuildRels is where relationship names are stored.

var BuildRels = struct {
    App                      string
    ResourceBuildAnnotations string
    ResourceBuildLabels      string
    KpackLifecycleData       string
}{
    App:                      "App",
    ResourceBuildAnnotations: "ResourceBuildAnnotations",
    ResourceBuildLabels:      "ResourceBuildLabels",
    KpackLifecycleData:       "KpackLifecycleData",
}
var BuildTableColumns = struct {
    ID                 string
    GUID               string
    CreatedAt          string
    UpdatedAt          string
    State              string
    PackageGUID        string
    ErrorDescription   string
    AppGUID            string
    ErrorID            string
    CreatedByUserGUID  string
    CreatedByUserName  string
    CreatedByUserEmail string
    StagingMemoryInMB  string
    StagingDiskInMB    string
}{
    ID:                 "builds.id",
    GUID:               "builds.guid",
    CreatedAt:          "builds.created_at",
    UpdatedAt:          "builds.updated_at",
    State:              "builds.state",
    PackageGUID:        "builds.package_guid",
    ErrorDescription:   "builds.error_description",
    AppGUID:            "builds.app_guid",
    ErrorID:            "builds.error_id",
    CreatedByUserGUID:  "builds.created_by_user_guid",
    CreatedByUserName:  "builds.created_by_user_name",
    CreatedByUserEmail: "builds.created_by_user_email",
    StagingMemoryInMB:  "builds.staging_memory_in_mb",
    StagingDiskInMB:    "builds.staging_disk_in_mb",
}
var BuildWhere = struct {
    ID                 whereHelperint
    GUID               whereHelperstring
    CreatedAt          whereHelpertime_Time
    UpdatedAt          whereHelpernull_Time
    State              whereHelpernull_String
    PackageGUID        whereHelpernull_String
    ErrorDescription   whereHelpernull_String
    AppGUID            whereHelpernull_String
    ErrorID            whereHelpernull_String
    CreatedByUserGUID  whereHelpernull_String
    CreatedByUserName  whereHelpernull_String
    CreatedByUserEmail whereHelpernull_String
    StagingMemoryInMB  whereHelpernull_Int
    StagingDiskInMB    whereHelpernull_Int
}{
    ID:                 whereHelperint{field: "\"builds\".\"id\""},
    GUID:               whereHelperstring{field: "\"builds\".\"guid\""},
    CreatedAt:          whereHelpertime_Time{field: "\"builds\".\"created_at\""},
    UpdatedAt:          whereHelpernull_Time{field: "\"builds\".\"updated_at\""},
    State:              whereHelpernull_String{field: "\"builds\".\"state\""},
    PackageGUID:        whereHelpernull_String{field: "\"builds\".\"package_guid\""},
    ErrorDescription:   whereHelpernull_String{field: "\"builds\".\"error_description\""},
    AppGUID:            whereHelpernull_String{field: "\"builds\".\"app_guid\""},
    ErrorID:            whereHelpernull_String{field: "\"builds\".\"error_id\""},
    CreatedByUserGUID:  whereHelpernull_String{field: "\"builds\".\"created_by_user_guid\""},
    CreatedByUserName:  whereHelpernull_String{field: "\"builds\".\"created_by_user_name\""},
    CreatedByUserEmail: whereHelpernull_String{field: "\"builds\".\"created_by_user_email\""},
    StagingMemoryInMB:  whereHelpernull_Int{field: "\"builds\".\"staging_memory_in_mb\""},
    StagingDiskInMB:    whereHelpernull_Int{field: "\"builds\".\"staging_disk_in_mb\""},
}
var BuildpackAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

BuildpackAnnotationRels is where relationship names are stored.

var BuildpackAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var BuildpackAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "buildpack_annotations.id",
    GUID:         "buildpack_annotations.guid",
    CreatedAt:    "buildpack_annotations.created_at",
    UpdatedAt:    "buildpack_annotations.updated_at",
    ResourceGUID: "buildpack_annotations.resource_guid",
    KeyPrefix:    "buildpack_annotations.key_prefix",
    Key:          "buildpack_annotations.key",
    Value:        "buildpack_annotations.value",
}
var BuildpackAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"buildpack_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"buildpack_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"buildpack_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"buildpack_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"buildpack_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"buildpack_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"buildpack_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"buildpack_annotations\".\"value\""},
}
var BuildpackColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    Name           string
    Key            string
    Position       string
    Enabled        string
    Locked         string
    Filename       string
    Sha256Checksum string
    Stack          string
}{
    ID:             "id",
    GUID:           "guid",
    CreatedAt:      "created_at",
    UpdatedAt:      "updated_at",
    Name:           "name",
    Key:            "key",
    Position:       "position",
    Enabled:        "enabled",
    Locked:         "locked",
    Filename:       "filename",
    Sha256Checksum: "sha256_checksum",
    Stack:          "stack",
}
var BuildpackLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

BuildpackLabelRels is where relationship names are stored.

var BuildpackLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var BuildpackLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "buildpack_labels.id",
    GUID:         "buildpack_labels.guid",
    CreatedAt:    "buildpack_labels.created_at",
    UpdatedAt:    "buildpack_labels.updated_at",
    ResourceGUID: "buildpack_labels.resource_guid",
    KeyPrefix:    "buildpack_labels.key_prefix",
    KeyName:      "buildpack_labels.key_name",
    Value:        "buildpack_labels.value",
}
var BuildpackLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"buildpack_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"buildpack_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"buildpack_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"buildpack_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"buildpack_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"buildpack_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"buildpack_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"buildpack_labels\".\"value\""},
}
var BuildpackLifecycleBuildpackColumns = struct {
    ID                         string
    GUID                       string
    CreatedAt                  string
    UpdatedAt                  string
    AdminBuildpackName         string
    EncryptedBuildpackURL      string
    EncryptedBuildpackURLSalt  string
    BuildpackLifecycleDataGUID string
    EncryptionKeyLabel         string
    Version                    string
    BuildpackName              string
    EncryptionIterations       string
}{
    ID:                         "id",
    GUID:                       "guid",
    CreatedAt:                  "created_at",
    UpdatedAt:                  "updated_at",
    AdminBuildpackName:         "admin_buildpack_name",
    EncryptedBuildpackURL:      "encrypted_buildpack_url",
    EncryptedBuildpackURLSalt:  "encrypted_buildpack_url_salt",
    BuildpackLifecycleDataGUID: "buildpack_lifecycle_data_guid",
    EncryptionKeyLabel:         "encryption_key_label",
    Version:                    "version",
    BuildpackName:              "buildpack_name",
    EncryptionIterations:       "encryption_iterations",
}

BuildpackLifecycleBuildpackRels is where relationship names are stored.

var BuildpackLifecycleBuildpackRels = struct {
    BuildpackLifecycleDatum string
}{
    BuildpackLifecycleDatum: "BuildpackLifecycleDatum",
}
var BuildpackLifecycleBuildpackTableColumns = struct {
    ID                         string
    GUID                       string
    CreatedAt                  string
    UpdatedAt                  string
    AdminBuildpackName         string
    EncryptedBuildpackURL      string
    EncryptedBuildpackURLSalt  string
    BuildpackLifecycleDataGUID string
    EncryptionKeyLabel         string
    Version                    string
    BuildpackName              string
    EncryptionIterations       string
}{
    ID:                         "buildpack_lifecycle_buildpacks.id",
    GUID:                       "buildpack_lifecycle_buildpacks.guid",
    CreatedAt:                  "buildpack_lifecycle_buildpacks.created_at",
    UpdatedAt:                  "buildpack_lifecycle_buildpacks.updated_at",
    AdminBuildpackName:         "buildpack_lifecycle_buildpacks.admin_buildpack_name",
    EncryptedBuildpackURL:      "buildpack_lifecycle_buildpacks.encrypted_buildpack_url",
    EncryptedBuildpackURLSalt:  "buildpack_lifecycle_buildpacks.encrypted_buildpack_url_salt",
    BuildpackLifecycleDataGUID: "buildpack_lifecycle_buildpacks.buildpack_lifecycle_data_guid",
    EncryptionKeyLabel:         "buildpack_lifecycle_buildpacks.encryption_key_label",
    Version:                    "buildpack_lifecycle_buildpacks.version",
    BuildpackName:              "buildpack_lifecycle_buildpacks.buildpack_name",
    EncryptionIterations:       "buildpack_lifecycle_buildpacks.encryption_iterations",
}
var BuildpackLifecycleBuildpackWhere = struct {
    ID                         whereHelperint
    GUID                       whereHelperstring
    CreatedAt                  whereHelpertime_Time
    UpdatedAt                  whereHelpernull_Time
    AdminBuildpackName         whereHelpernull_String
    EncryptedBuildpackURL      whereHelpernull_String
    EncryptedBuildpackURLSalt  whereHelpernull_String
    BuildpackLifecycleDataGUID whereHelpernull_String
    EncryptionKeyLabel         whereHelpernull_String
    Version                    whereHelpernull_String
    BuildpackName              whereHelpernull_String
    EncryptionIterations       whereHelperint
}{
    ID:                         whereHelperint{field: "\"buildpack_lifecycle_buildpacks\".\"id\""},
    GUID:                       whereHelperstring{field: "\"buildpack_lifecycle_buildpacks\".\"guid\""},
    CreatedAt:                  whereHelpertime_Time{field: "\"buildpack_lifecycle_buildpacks\".\"created_at\""},
    UpdatedAt:                  whereHelpernull_Time{field: "\"buildpack_lifecycle_buildpacks\".\"updated_at\""},
    AdminBuildpackName:         whereHelpernull_String{field: "\"buildpack_lifecycle_buildpacks\".\"admin_buildpack_name\""},
    EncryptedBuildpackURL:      whereHelpernull_String{field: "\"buildpack_lifecycle_buildpacks\".\"encrypted_buildpack_url\""},
    EncryptedBuildpackURLSalt:  whereHelpernull_String{field: "\"buildpack_lifecycle_buildpacks\".\"encrypted_buildpack_url_salt\""},
    BuildpackLifecycleDataGUID: whereHelpernull_String{field: "\"buildpack_lifecycle_buildpacks\".\"buildpack_lifecycle_data_guid\""},
    EncryptionKeyLabel:         whereHelpernull_String{field: "\"buildpack_lifecycle_buildpacks\".\"encryption_key_label\""},
    Version:                    whereHelpernull_String{field: "\"buildpack_lifecycle_buildpacks\".\"version\""},
    BuildpackName:              whereHelpernull_String{field: "\"buildpack_lifecycle_buildpacks\".\"buildpack_name\""},
    EncryptionIterations:       whereHelperint{field: "\"buildpack_lifecycle_buildpacks\".\"encryption_iterations\""},
}
var BuildpackLifecycleDatumColumns = struct {
    ID                        string
    GUID                      string
    CreatedAt                 string
    UpdatedAt                 string
    AppGUID                   string
    DropletGUID               string
    Stack                     string
    EncryptedBuildpackURL     string
    EncryptedBuildpackURLSalt string
    AdminBuildpackName        string
    BuildGUID                 string
    EncryptionKeyLabel        string
    EncryptionIterations      string
}{
    ID:                        "id",
    GUID:                      "guid",
    CreatedAt:                 "created_at",
    UpdatedAt:                 "updated_at",
    AppGUID:                   "app_guid",
    DropletGUID:               "droplet_guid",
    Stack:                     "stack",
    EncryptedBuildpackURL:     "encrypted_buildpack_url",
    EncryptedBuildpackURLSalt: "encrypted_buildpack_url_salt",
    AdminBuildpackName:        "admin_buildpack_name",
    BuildGUID:                 "build_guid",
    EncryptionKeyLabel:        "encryption_key_label",
    EncryptionIterations:      "encryption_iterations",
}

BuildpackLifecycleDatumRels is where relationship names are stored.

var BuildpackLifecycleDatumRels = struct {
    BuildpackLifecycleBuildpacks string
}{
    BuildpackLifecycleBuildpacks: "BuildpackLifecycleBuildpacks",
}
var BuildpackLifecycleDatumTableColumns = struct {
    ID                        string
    GUID                      string
    CreatedAt                 string
    UpdatedAt                 string
    AppGUID                   string
    DropletGUID               string
    Stack                     string
    EncryptedBuildpackURL     string
    EncryptedBuildpackURLSalt string
    AdminBuildpackName        string
    BuildGUID                 string
    EncryptionKeyLabel        string
    EncryptionIterations      string
}{
    ID:                        "buildpack_lifecycle_data.id",
    GUID:                      "buildpack_lifecycle_data.guid",
    CreatedAt:                 "buildpack_lifecycle_data.created_at",
    UpdatedAt:                 "buildpack_lifecycle_data.updated_at",
    AppGUID:                   "buildpack_lifecycle_data.app_guid",
    DropletGUID:               "buildpack_lifecycle_data.droplet_guid",
    Stack:                     "buildpack_lifecycle_data.stack",
    EncryptedBuildpackURL:     "buildpack_lifecycle_data.encrypted_buildpack_url",
    EncryptedBuildpackURLSalt: "buildpack_lifecycle_data.encrypted_buildpack_url_salt",
    AdminBuildpackName:        "buildpack_lifecycle_data.admin_buildpack_name",
    BuildGUID:                 "buildpack_lifecycle_data.build_guid",
    EncryptionKeyLabel:        "buildpack_lifecycle_data.encryption_key_label",
    EncryptionIterations:      "buildpack_lifecycle_data.encryption_iterations",
}
var BuildpackLifecycleDatumWhere = struct {
    ID                        whereHelperint
    GUID                      whereHelperstring
    CreatedAt                 whereHelpertime_Time
    UpdatedAt                 whereHelpernull_Time
    AppGUID                   whereHelpernull_String
    DropletGUID               whereHelpernull_String
    Stack                     whereHelpernull_String
    EncryptedBuildpackURL     whereHelpernull_String
    EncryptedBuildpackURLSalt whereHelpernull_String
    AdminBuildpackName        whereHelpernull_String
    BuildGUID                 whereHelpernull_String
    EncryptionKeyLabel        whereHelpernull_String
    EncryptionIterations      whereHelperint
}{
    ID:                        whereHelperint{field: "\"buildpack_lifecycle_data\".\"id\""},
    GUID:                      whereHelperstring{field: "\"buildpack_lifecycle_data\".\"guid\""},
    CreatedAt:                 whereHelpertime_Time{field: "\"buildpack_lifecycle_data\".\"created_at\""},
    UpdatedAt:                 whereHelpernull_Time{field: "\"buildpack_lifecycle_data\".\"updated_at\""},
    AppGUID:                   whereHelpernull_String{field: "\"buildpack_lifecycle_data\".\"app_guid\""},
    DropletGUID:               whereHelpernull_String{field: "\"buildpack_lifecycle_data\".\"droplet_guid\""},
    Stack:                     whereHelpernull_String{field: "\"buildpack_lifecycle_data\".\"stack\""},
    EncryptedBuildpackURL:     whereHelpernull_String{field: "\"buildpack_lifecycle_data\".\"encrypted_buildpack_url\""},
    EncryptedBuildpackURLSalt: whereHelpernull_String{field: "\"buildpack_lifecycle_data\".\"encrypted_buildpack_url_salt\""},
    AdminBuildpackName:        whereHelpernull_String{field: "\"buildpack_lifecycle_data\".\"admin_buildpack_name\""},
    BuildGUID:                 whereHelpernull_String{field: "\"buildpack_lifecycle_data\".\"build_guid\""},
    EncryptionKeyLabel:        whereHelpernull_String{field: "\"buildpack_lifecycle_data\".\"encryption_key_label\""},
    EncryptionIterations:      whereHelperint{field: "\"buildpack_lifecycle_data\".\"encryption_iterations\""},
}

BuildpackRels is where relationship names are stored.

var BuildpackRels = struct {
    ResourceBuildpackAnnotations string
    ResourceBuildpackLabels      string
}{
    ResourceBuildpackAnnotations: "ResourceBuildpackAnnotations",
    ResourceBuildpackLabels:      "ResourceBuildpackLabels",
}
var BuildpackTableColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    Name           string
    Key            string
    Position       string
    Enabled        string
    Locked         string
    Filename       string
    Sha256Checksum string
    Stack          string
}{
    ID:             "buildpacks.id",
    GUID:           "buildpacks.guid",
    CreatedAt:      "buildpacks.created_at",
    UpdatedAt:      "buildpacks.updated_at",
    Name:           "buildpacks.name",
    Key:            "buildpacks.key",
    Position:       "buildpacks.position",
    Enabled:        "buildpacks.enabled",
    Locked:         "buildpacks.locked",
    Filename:       "buildpacks.filename",
    Sha256Checksum: "buildpacks.sha256_checksum",
    Stack:          "buildpacks.stack",
}
var BuildpackWhere = struct {
    ID             whereHelperint
    GUID           whereHelperstring
    CreatedAt      whereHelpertime_Time
    UpdatedAt      whereHelpernull_Time
    Name           whereHelperstring
    Key            whereHelpernull_String
    Position       whereHelperint
    Enabled        whereHelpernull_Bool
    Locked         whereHelpernull_Bool
    Filename       whereHelpernull_String
    Sha256Checksum whereHelpernull_String
    Stack          whereHelpernull_String
}{
    ID:             whereHelperint{field: "\"buildpacks\".\"id\""},
    GUID:           whereHelperstring{field: "\"buildpacks\".\"guid\""},
    CreatedAt:      whereHelpertime_Time{field: "\"buildpacks\".\"created_at\""},
    UpdatedAt:      whereHelpernull_Time{field: "\"buildpacks\".\"updated_at\""},
    Name:           whereHelperstring{field: "\"buildpacks\".\"name\""},
    Key:            whereHelpernull_String{field: "\"buildpacks\".\"key\""},
    Position:       whereHelperint{field: "\"buildpacks\".\"position\""},
    Enabled:        whereHelpernull_Bool{field: "\"buildpacks\".\"enabled\""},
    Locked:         whereHelpernull_Bool{field: "\"buildpacks\".\"locked\""},
    Filename:       whereHelpernull_String{field: "\"buildpacks\".\"filename\""},
    Sha256Checksum: whereHelpernull_String{field: "\"buildpacks\".\"sha256_checksum\""},
    Stack:          whereHelpernull_String{field: "\"buildpacks\".\"stack\""},
}
var ClockJobColumns = struct {
    ID              string
    Name            string
    LastStartedAt   string
    LastCompletedAt string
}{
    ID:              "id",
    Name:            "name",
    LastStartedAt:   "last_started_at",
    LastCompletedAt: "last_completed_at",
}

ClockJobRels is where relationship names are stored.

var ClockJobRels = struct {
}{}
var ClockJobTableColumns = struct {
    ID              string
    Name            string
    LastStartedAt   string
    LastCompletedAt string
}{
    ID:              "clock_jobs.id",
    Name:            "clock_jobs.name",
    LastStartedAt:   "clock_jobs.last_started_at",
    LastCompletedAt: "clock_jobs.last_completed_at",
}
var ClockJobWhere = struct {
    ID              whereHelperint
    Name            whereHelperstring
    LastStartedAt   whereHelpernull_Time
    LastCompletedAt whereHelpernull_Time
}{
    ID:              whereHelperint{field: "\"clock_jobs\".\"id\""},
    Name:            whereHelperstring{field: "\"clock_jobs\".\"name\""},
    LastStartedAt:   whereHelpernull_Time{field: "\"clock_jobs\".\"last_started_at\""},
    LastCompletedAt: whereHelpernull_Time{field: "\"clock_jobs\".\"last_completed_at\""},
}
var DelayedJobColumns = struct {
    ID         string
    GUID       string
    CreatedAt  string
    UpdatedAt  string
    Priority   string
    Attempts   string
    Handler    string
    LastError  string
    RunAt      string
    LockedAt   string
    FailedAt   string
    LockedBy   string
    Queue      string
    CFAPIError string
}{
    ID:         "id",
    GUID:       "guid",
    CreatedAt:  "created_at",
    UpdatedAt:  "updated_at",
    Priority:   "priority",
    Attempts:   "attempts",
    Handler:    "handler",
    LastError:  "last_error",
    RunAt:      "run_at",
    LockedAt:   "locked_at",
    FailedAt:   "failed_at",
    LockedBy:   "locked_by",
    Queue:      "queue",
    CFAPIError: "cf_api_error",
}

DelayedJobRels is where relationship names are stored.

var DelayedJobRels = struct {
}{}
var DelayedJobTableColumns = struct {
    ID         string
    GUID       string
    CreatedAt  string
    UpdatedAt  string
    Priority   string
    Attempts   string
    Handler    string
    LastError  string
    RunAt      string
    LockedAt   string
    FailedAt   string
    LockedBy   string
    Queue      string
    CFAPIError string
}{
    ID:         "delayed_jobs.id",
    GUID:       "delayed_jobs.guid",
    CreatedAt:  "delayed_jobs.created_at",
    UpdatedAt:  "delayed_jobs.updated_at",
    Priority:   "delayed_jobs.priority",
    Attempts:   "delayed_jobs.attempts",
    Handler:    "delayed_jobs.handler",
    LastError:  "delayed_jobs.last_error",
    RunAt:      "delayed_jobs.run_at",
    LockedAt:   "delayed_jobs.locked_at",
    FailedAt:   "delayed_jobs.failed_at",
    LockedBy:   "delayed_jobs.locked_by",
    Queue:      "delayed_jobs.queue",
    CFAPIError: "delayed_jobs.cf_api_error",
}
var DelayedJobWhere = struct {
    ID         whereHelperint
    GUID       whereHelperstring
    CreatedAt  whereHelpertime_Time
    UpdatedAt  whereHelpernull_Time
    Priority   whereHelpernull_Int
    Attempts   whereHelpernull_Int
    Handler    whereHelpernull_String
    LastError  whereHelpernull_String
    RunAt      whereHelpernull_Time
    LockedAt   whereHelpernull_Time
    FailedAt   whereHelpernull_Time
    LockedBy   whereHelpernull_String
    Queue      whereHelpernull_String
    CFAPIError whereHelpernull_String
}{
    ID:         whereHelperint{field: "\"delayed_jobs\".\"id\""},
    GUID:       whereHelperstring{field: "\"delayed_jobs\".\"guid\""},
    CreatedAt:  whereHelpertime_Time{field: "\"delayed_jobs\".\"created_at\""},
    UpdatedAt:  whereHelpernull_Time{field: "\"delayed_jobs\".\"updated_at\""},
    Priority:   whereHelpernull_Int{field: "\"delayed_jobs\".\"priority\""},
    Attempts:   whereHelpernull_Int{field: "\"delayed_jobs\".\"attempts\""},
    Handler:    whereHelpernull_String{field: "\"delayed_jobs\".\"handler\""},
    LastError:  whereHelpernull_String{field: "\"delayed_jobs\".\"last_error\""},
    RunAt:      whereHelpernull_Time{field: "\"delayed_jobs\".\"run_at\""},
    LockedAt:   whereHelpernull_Time{field: "\"delayed_jobs\".\"locked_at\""},
    FailedAt:   whereHelpernull_Time{field: "\"delayed_jobs\".\"failed_at\""},
    LockedBy:   whereHelpernull_String{field: "\"delayed_jobs\".\"locked_by\""},
    Queue:      whereHelpernull_String{field: "\"delayed_jobs\".\"queue\""},
    CFAPIError: whereHelpernull_String{field: "\"delayed_jobs\".\"cf_api_error\""},
}
var DeploymentAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

DeploymentAnnotationRels is where relationship names are stored.

var DeploymentAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var DeploymentAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "deployment_annotations.id",
    GUID:         "deployment_annotations.guid",
    CreatedAt:    "deployment_annotations.created_at",
    UpdatedAt:    "deployment_annotations.updated_at",
    ResourceGUID: "deployment_annotations.resource_guid",
    KeyPrefix:    "deployment_annotations.key_prefix",
    Key:          "deployment_annotations.key",
    Value:        "deployment_annotations.value",
}
var DeploymentAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"deployment_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"deployment_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"deployment_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"deployment_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"deployment_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"deployment_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"deployment_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"deployment_annotations\".\"value\""},
}
var DeploymentColumns = struct {
    ID                              string
    GUID                            string
    CreatedAt                       string
    UpdatedAt                       string
    State                           string
    AppGUID                         string
    DropletGUID                     string
    DeployingWebProcessGUID         string
    PreviousDropletGUID             string
    OriginalWebProcessInstanceCount string
    RevisionGUID                    string
    RevisionVersion                 string
    LastHealthyAt                   string
    StatusValue                     string
    StatusReason                    string
    Strategy                        string
}{
    ID:                              "id",
    GUID:                            "guid",
    CreatedAt:                       "created_at",
    UpdatedAt:                       "updated_at",
    State:                           "state",
    AppGUID:                         "app_guid",
    DropletGUID:                     "droplet_guid",
    DeployingWebProcessGUID:         "deploying_web_process_guid",
    PreviousDropletGUID:             "previous_droplet_guid",
    OriginalWebProcessInstanceCount: "original_web_process_instance_count",
    RevisionGUID:                    "revision_guid",
    RevisionVersion:                 "revision_version",
    LastHealthyAt:                   "last_healthy_at",
    StatusValue:                     "status_value",
    StatusReason:                    "status_reason",
    Strategy:                        "strategy",
}
var DeploymentLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

DeploymentLabelRels is where relationship names are stored.

var DeploymentLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var DeploymentLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "deployment_labels.id",
    GUID:         "deployment_labels.guid",
    CreatedAt:    "deployment_labels.created_at",
    UpdatedAt:    "deployment_labels.updated_at",
    ResourceGUID: "deployment_labels.resource_guid",
    KeyPrefix:    "deployment_labels.key_prefix",
    KeyName:      "deployment_labels.key_name",
    Value:        "deployment_labels.value",
}
var DeploymentLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"deployment_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"deployment_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"deployment_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"deployment_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"deployment_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"deployment_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"deployment_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"deployment_labels\".\"value\""},
}
var DeploymentProcessColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    ProcessGUID    string
    ProcessType    string
    DeploymentGUID string
}{
    ID:             "id",
    GUID:           "guid",
    CreatedAt:      "created_at",
    UpdatedAt:      "updated_at",
    ProcessGUID:    "process_guid",
    ProcessType:    "process_type",
    DeploymentGUID: "deployment_guid",
}

DeploymentProcessRels is where relationship names are stored.

var DeploymentProcessRels = struct {
    Deployment string
}{
    Deployment: "Deployment",
}
var DeploymentProcessTableColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    ProcessGUID    string
    ProcessType    string
    DeploymentGUID string
}{
    ID:             "deployment_processes.id",
    GUID:           "deployment_processes.guid",
    CreatedAt:      "deployment_processes.created_at",
    UpdatedAt:      "deployment_processes.updated_at",
    ProcessGUID:    "deployment_processes.process_guid",
    ProcessType:    "deployment_processes.process_type",
    DeploymentGUID: "deployment_processes.deployment_guid",
}
var DeploymentProcessWhere = struct {
    ID             whereHelperint
    GUID           whereHelperstring
    CreatedAt      whereHelpertime_Time
    UpdatedAt      whereHelpernull_Time
    ProcessGUID    whereHelpernull_String
    ProcessType    whereHelpernull_String
    DeploymentGUID whereHelpernull_String
}{
    ID:             whereHelperint{field: "\"deployment_processes\".\"id\""},
    GUID:           whereHelperstring{field: "\"deployment_processes\".\"guid\""},
    CreatedAt:      whereHelpertime_Time{field: "\"deployment_processes\".\"created_at\""},
    UpdatedAt:      whereHelpernull_Time{field: "\"deployment_processes\".\"updated_at\""},
    ProcessGUID:    whereHelpernull_String{field: "\"deployment_processes\".\"process_guid\""},
    ProcessType:    whereHelpernull_String{field: "\"deployment_processes\".\"process_type\""},
    DeploymentGUID: whereHelpernull_String{field: "\"deployment_processes\".\"deployment_guid\""},
}

DeploymentRels is where relationship names are stored.

var DeploymentRels = struct {
    App                           string
    ResourceDeploymentAnnotations string
    ResourceDeploymentLabels      string
    DeploymentProcesses           string
}{
    App:                           "App",
    ResourceDeploymentAnnotations: "ResourceDeploymentAnnotations",
    ResourceDeploymentLabels:      "ResourceDeploymentLabels",
    DeploymentProcesses:           "DeploymentProcesses",
}
var DeploymentTableColumns = struct {
    ID                              string
    GUID                            string
    CreatedAt                       string
    UpdatedAt                       string
    State                           string
    AppGUID                         string
    DropletGUID                     string
    DeployingWebProcessGUID         string
    PreviousDropletGUID             string
    OriginalWebProcessInstanceCount string
    RevisionGUID                    string
    RevisionVersion                 string
    LastHealthyAt                   string
    StatusValue                     string
    StatusReason                    string
    Strategy                        string
}{
    ID:                              "deployments.id",
    GUID:                            "deployments.guid",
    CreatedAt:                       "deployments.created_at",
    UpdatedAt:                       "deployments.updated_at",
    State:                           "deployments.state",
    AppGUID:                         "deployments.app_guid",
    DropletGUID:                     "deployments.droplet_guid",
    DeployingWebProcessGUID:         "deployments.deploying_web_process_guid",
    PreviousDropletGUID:             "deployments.previous_droplet_guid",
    OriginalWebProcessInstanceCount: "deployments.original_web_process_instance_count",
    RevisionGUID:                    "deployments.revision_guid",
    RevisionVersion:                 "deployments.revision_version",
    LastHealthyAt:                   "deployments.last_healthy_at",
    StatusValue:                     "deployments.status_value",
    StatusReason:                    "deployments.status_reason",
    Strategy:                        "deployments.strategy",
}
var DeploymentWhere = struct {
    ID                              whereHelperint
    GUID                            whereHelperstring
    CreatedAt                       whereHelpertime_Time
    UpdatedAt                       whereHelpernull_Time
    State                           whereHelpernull_String
    AppGUID                         whereHelpernull_String
    DropletGUID                     whereHelpernull_String
    DeployingWebProcessGUID         whereHelpernull_String
    PreviousDropletGUID             whereHelpernull_String
    OriginalWebProcessInstanceCount whereHelperint
    RevisionGUID                    whereHelpernull_String
    RevisionVersion                 whereHelpernull_Int
    LastHealthyAt                   whereHelpertime_Time
    StatusValue                     whereHelpernull_String
    StatusReason                    whereHelpernull_String
    Strategy                        whereHelperstring
}{
    ID:                              whereHelperint{field: "\"deployments\".\"id\""},
    GUID:                            whereHelperstring{field: "\"deployments\".\"guid\""},
    CreatedAt:                       whereHelpertime_Time{field: "\"deployments\".\"created_at\""},
    UpdatedAt:                       whereHelpernull_Time{field: "\"deployments\".\"updated_at\""},
    State:                           whereHelpernull_String{field: "\"deployments\".\"state\""},
    AppGUID:                         whereHelpernull_String{field: "\"deployments\".\"app_guid\""},
    DropletGUID:                     whereHelpernull_String{field: "\"deployments\".\"droplet_guid\""},
    DeployingWebProcessGUID:         whereHelpernull_String{field: "\"deployments\".\"deploying_web_process_guid\""},
    PreviousDropletGUID:             whereHelpernull_String{field: "\"deployments\".\"previous_droplet_guid\""},
    OriginalWebProcessInstanceCount: whereHelperint{field: "\"deployments\".\"original_web_process_instance_count\""},
    RevisionGUID:                    whereHelpernull_String{field: "\"deployments\".\"revision_guid\""},
    RevisionVersion:                 whereHelpernull_Int{field: "\"deployments\".\"revision_version\""},
    LastHealthyAt:                   whereHelpertime_Time{field: "\"deployments\".\"last_healthy_at\""},
    StatusValue:                     whereHelpernull_String{field: "\"deployments\".\"status_value\""},
    StatusReason:                    whereHelpernull_String{field: "\"deployments\".\"status_reason\""},
    Strategy:                        whereHelperstring{field: "\"deployments\".\"strategy\""},
}
var DomainAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

DomainAnnotationRels is where relationship names are stored.

var DomainAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var DomainAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "domain_annotations.id",
    GUID:         "domain_annotations.guid",
    CreatedAt:    "domain_annotations.created_at",
    UpdatedAt:    "domain_annotations.updated_at",
    ResourceGUID: "domain_annotations.resource_guid",
    KeyPrefix:    "domain_annotations.key_prefix",
    Key:          "domain_annotations.key",
    Value:        "domain_annotations.value",
}
var DomainAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"domain_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"domain_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"domain_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"domain_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"domain_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"domain_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"domain_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"domain_annotations\".\"value\""},
}
var DomainColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    Wildcard             string
    OwningOrganizationID string
    RouterGroupGUID      string
    Internal             string
}{
    ID:                   "id",
    GUID:                 "guid",
    CreatedAt:            "created_at",
    UpdatedAt:            "updated_at",
    Name:                 "name",
    Wildcard:             "wildcard",
    OwningOrganizationID: "owning_organization_id",
    RouterGroupGUID:      "router_group_guid",
    Internal:             "internal",
}
var DomainLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

DomainLabelRels is where relationship names are stored.

var DomainLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var DomainLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "domain_labels.id",
    GUID:         "domain_labels.guid",
    CreatedAt:    "domain_labels.created_at",
    UpdatedAt:    "domain_labels.updated_at",
    ResourceGUID: "domain_labels.resource_guid",
    KeyPrefix:    "domain_labels.key_prefix",
    KeyName:      "domain_labels.key_name",
    Value:        "domain_labels.value",
}
var DomainLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"domain_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"domain_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"domain_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"domain_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"domain_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"domain_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"domain_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"domain_labels\".\"value\""},
}

DomainRels is where relationship names are stored.

var DomainRels = struct {
    OwningOrganization                       string
    ResourceDomainAnnotations                string
    ResourceDomainLabels                     string
    PrivateDomainOrganizationsPrivateDomains string
    Routes                                   string
}{
    OwningOrganization:                       "OwningOrganization",
    ResourceDomainAnnotations:                "ResourceDomainAnnotations",
    ResourceDomainLabels:                     "ResourceDomainLabels",
    PrivateDomainOrganizationsPrivateDomains: "PrivateDomainOrganizationsPrivateDomains",
    Routes:                                   "Routes",
}
var DomainTableColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    Wildcard             string
    OwningOrganizationID string
    RouterGroupGUID      string
    Internal             string
}{
    ID:                   "domains.id",
    GUID:                 "domains.guid",
    CreatedAt:            "domains.created_at",
    UpdatedAt:            "domains.updated_at",
    Name:                 "domains.name",
    Wildcard:             "domains.wildcard",
    OwningOrganizationID: "domains.owning_organization_id",
    RouterGroupGUID:      "domains.router_group_guid",
    Internal:             "domains.internal",
}
var DomainWhere = struct {
    ID                   whereHelperint
    GUID                 whereHelperstring
    CreatedAt            whereHelpertime_Time
    UpdatedAt            whereHelpernull_Time
    Name                 whereHelperstring
    Wildcard             whereHelperbool
    OwningOrganizationID whereHelpernull_Int
    RouterGroupGUID      whereHelpernull_String
    Internal             whereHelpernull_Bool
}{
    ID:                   whereHelperint{field: "\"domains\".\"id\""},
    GUID:                 whereHelperstring{field: "\"domains\".\"guid\""},
    CreatedAt:            whereHelpertime_Time{field: "\"domains\".\"created_at\""},
    UpdatedAt:            whereHelpernull_Time{field: "\"domains\".\"updated_at\""},
    Name:                 whereHelperstring{field: "\"domains\".\"name\""},
    Wildcard:             whereHelperbool{field: "\"domains\".\"wildcard\""},
    OwningOrganizationID: whereHelpernull_Int{field: "\"domains\".\"owning_organization_id\""},
    RouterGroupGUID:      whereHelpernull_String{field: "\"domains\".\"router_group_guid\""},
    Internal:             whereHelpernull_Bool{field: "\"domains\".\"internal\""},
}
var DropletAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

DropletAnnotationRels is where relationship names are stored.

var DropletAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var DropletAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "droplet_annotations.id",
    GUID:         "droplet_annotations.guid",
    CreatedAt:    "droplet_annotations.created_at",
    UpdatedAt:    "droplet_annotations.updated_at",
    ResourceGUID: "droplet_annotations.resource_guid",
    KeyPrefix:    "droplet_annotations.key_prefix",
    Key:          "droplet_annotations.key",
    Value:        "droplet_annotations.value",
}
var DropletAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"droplet_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"droplet_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"droplet_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"droplet_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"droplet_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"droplet_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"droplet_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"droplet_annotations\".\"value\""},
}
var DropletColumns = struct {
    ID                             string
    GUID                           string
    CreatedAt                      string
    UpdatedAt                      string
    DropletHash                    string
    ExecutionMetadata              string
    State                          string
    ProcessTypes                   string
    ErrorID                        string
    ErrorDescription               string
    EncryptedEnvironmentVariables  string
    Salt                           string
    StagingMemoryInMB              string
    StagingDiskInMB                string
    BuildpackReceiptBuildpack      string
    BuildpackReceiptBuildpackGUID  string
    BuildpackReceiptDetectOutput   string
    DockerReceiptImage             string
    PackageGUID                    string
    AppGUID                        string
    Sha256Checksum                 string
    BuildGUID                      string
    DockerReceiptUsername          string
    DockerReceiptPasswordSalt      string
    EncryptedDockerReceiptPassword string
    EncryptionKeyLabel             string
    EncryptionIterations           string
    Sidecars                       string
}{
    ID:                             "id",
    GUID:                           "guid",
    CreatedAt:                      "created_at",
    UpdatedAt:                      "updated_at",
    DropletHash:                    "droplet_hash",
    ExecutionMetadata:              "execution_metadata",
    State:                          "state",
    ProcessTypes:                   "process_types",
    ErrorID:                        "error_id",
    ErrorDescription:               "error_description",
    EncryptedEnvironmentVariables:  "encrypted_environment_variables",
    Salt:                           "salt",
    StagingMemoryInMB:              "staging_memory_in_mb",
    StagingDiskInMB:                "staging_disk_in_mb",
    BuildpackReceiptBuildpack:      "buildpack_receipt_buildpack",
    BuildpackReceiptBuildpackGUID:  "buildpack_receipt_buildpack_guid",
    BuildpackReceiptDetectOutput:   "buildpack_receipt_detect_output",
    DockerReceiptImage:             "docker_receipt_image",
    PackageGUID:                    "package_guid",
    AppGUID:                        "app_guid",
    Sha256Checksum:                 "sha256_checksum",
    BuildGUID:                      "build_guid",
    DockerReceiptUsername:          "docker_receipt_username",
    DockerReceiptPasswordSalt:      "docker_receipt_password_salt",
    EncryptedDockerReceiptPassword: "encrypted_docker_receipt_password",
    EncryptionKeyLabel:             "encryption_key_label",
    EncryptionIterations:           "encryption_iterations",
    Sidecars:                       "sidecars",
}
var DropletLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

DropletLabelRels is where relationship names are stored.

var DropletLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var DropletLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "droplet_labels.id",
    GUID:         "droplet_labels.guid",
    CreatedAt:    "droplet_labels.created_at",
    UpdatedAt:    "droplet_labels.updated_at",
    ResourceGUID: "droplet_labels.resource_guid",
    KeyPrefix:    "droplet_labels.key_prefix",
    KeyName:      "droplet_labels.key_name",
    Value:        "droplet_labels.value",
}
var DropletLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"droplet_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"droplet_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"droplet_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"droplet_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"droplet_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"droplet_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"droplet_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"droplet_labels\".\"value\""},
}

DropletRels is where relationship names are stored.

var DropletRels = struct {
    App                        string
    ResourceDropletAnnotations string
    ResourceDropletLabels      string
}{
    App:                        "App",
    ResourceDropletAnnotations: "ResourceDropletAnnotations",
    ResourceDropletLabels:      "ResourceDropletLabels",
}
var DropletTableColumns = struct {
    ID                             string
    GUID                           string
    CreatedAt                      string
    UpdatedAt                      string
    DropletHash                    string
    ExecutionMetadata              string
    State                          string
    ProcessTypes                   string
    ErrorID                        string
    ErrorDescription               string
    EncryptedEnvironmentVariables  string
    Salt                           string
    StagingMemoryInMB              string
    StagingDiskInMB                string
    BuildpackReceiptBuildpack      string
    BuildpackReceiptBuildpackGUID  string
    BuildpackReceiptDetectOutput   string
    DockerReceiptImage             string
    PackageGUID                    string
    AppGUID                        string
    Sha256Checksum                 string
    BuildGUID                      string
    DockerReceiptUsername          string
    DockerReceiptPasswordSalt      string
    EncryptedDockerReceiptPassword string
    EncryptionKeyLabel             string
    EncryptionIterations           string
    Sidecars                       string
}{
    ID:                             "droplets.id",
    GUID:                           "droplets.guid",
    CreatedAt:                      "droplets.created_at",
    UpdatedAt:                      "droplets.updated_at",
    DropletHash:                    "droplets.droplet_hash",
    ExecutionMetadata:              "droplets.execution_metadata",
    State:                          "droplets.state",
    ProcessTypes:                   "droplets.process_types",
    ErrorID:                        "droplets.error_id",
    ErrorDescription:               "droplets.error_description",
    EncryptedEnvironmentVariables:  "droplets.encrypted_environment_variables",
    Salt:                           "droplets.salt",
    StagingMemoryInMB:              "droplets.staging_memory_in_mb",
    StagingDiskInMB:                "droplets.staging_disk_in_mb",
    BuildpackReceiptBuildpack:      "droplets.buildpack_receipt_buildpack",
    BuildpackReceiptBuildpackGUID:  "droplets.buildpack_receipt_buildpack_guid",
    BuildpackReceiptDetectOutput:   "droplets.buildpack_receipt_detect_output",
    DockerReceiptImage:             "droplets.docker_receipt_image",
    PackageGUID:                    "droplets.package_guid",
    AppGUID:                        "droplets.app_guid",
    Sha256Checksum:                 "droplets.sha256_checksum",
    BuildGUID:                      "droplets.build_guid",
    DockerReceiptUsername:          "droplets.docker_receipt_username",
    DockerReceiptPasswordSalt:      "droplets.docker_receipt_password_salt",
    EncryptedDockerReceiptPassword: "droplets.encrypted_docker_receipt_password",
    EncryptionKeyLabel:             "droplets.encryption_key_label",
    EncryptionIterations:           "droplets.encryption_iterations",
    Sidecars:                       "droplets.sidecars",
}
var DropletWhere = struct {
    ID                             whereHelperint
    GUID                           whereHelperstring
    CreatedAt                      whereHelpertime_Time
    UpdatedAt                      whereHelpernull_Time
    DropletHash                    whereHelpernull_String
    ExecutionMetadata              whereHelpernull_String
    State                          whereHelperstring
    ProcessTypes                   whereHelpernull_String
    ErrorID                        whereHelpernull_String
    ErrorDescription               whereHelpernull_String
    EncryptedEnvironmentVariables  whereHelpernull_String
    Salt                           whereHelpernull_String
    StagingMemoryInMB              whereHelpernull_Int
    StagingDiskInMB                whereHelpernull_Int
    BuildpackReceiptBuildpack      whereHelpernull_String
    BuildpackReceiptBuildpackGUID  whereHelpernull_String
    BuildpackReceiptDetectOutput   whereHelpernull_String
    DockerReceiptImage             whereHelpernull_String
    PackageGUID                    whereHelpernull_String
    AppGUID                        whereHelpernull_String
    Sha256Checksum                 whereHelpernull_String
    BuildGUID                      whereHelpernull_String
    DockerReceiptUsername          whereHelpernull_String
    DockerReceiptPasswordSalt      whereHelpernull_String
    EncryptedDockerReceiptPassword whereHelpernull_String
    EncryptionKeyLabel             whereHelpernull_String
    EncryptionIterations           whereHelperint
    Sidecars                       whereHelpernull_String
}{
    ID:                             whereHelperint{field: "\"droplets\".\"id\""},
    GUID:                           whereHelperstring{field: "\"droplets\".\"guid\""},
    CreatedAt:                      whereHelpertime_Time{field: "\"droplets\".\"created_at\""},
    UpdatedAt:                      whereHelpernull_Time{field: "\"droplets\".\"updated_at\""},
    DropletHash:                    whereHelpernull_String{field: "\"droplets\".\"droplet_hash\""},
    ExecutionMetadata:              whereHelpernull_String{field: "\"droplets\".\"execution_metadata\""},
    State:                          whereHelperstring{field: "\"droplets\".\"state\""},
    ProcessTypes:                   whereHelpernull_String{field: "\"droplets\".\"process_types\""},
    ErrorID:                        whereHelpernull_String{field: "\"droplets\".\"error_id\""},
    ErrorDescription:               whereHelpernull_String{field: "\"droplets\".\"error_description\""},
    EncryptedEnvironmentVariables:  whereHelpernull_String{field: "\"droplets\".\"encrypted_environment_variables\""},
    Salt:                           whereHelpernull_String{field: "\"droplets\".\"salt\""},
    StagingMemoryInMB:              whereHelpernull_Int{field: "\"droplets\".\"staging_memory_in_mb\""},
    StagingDiskInMB:                whereHelpernull_Int{field: "\"droplets\".\"staging_disk_in_mb\""},
    BuildpackReceiptBuildpack:      whereHelpernull_String{field: "\"droplets\".\"buildpack_receipt_buildpack\""},
    BuildpackReceiptBuildpackGUID:  whereHelpernull_String{field: "\"droplets\".\"buildpack_receipt_buildpack_guid\""},
    BuildpackReceiptDetectOutput:   whereHelpernull_String{field: "\"droplets\".\"buildpack_receipt_detect_output\""},
    DockerReceiptImage:             whereHelpernull_String{field: "\"droplets\".\"docker_receipt_image\""},
    PackageGUID:                    whereHelpernull_String{field: "\"droplets\".\"package_guid\""},
    AppGUID:                        whereHelpernull_String{field: "\"droplets\".\"app_guid\""},
    Sha256Checksum:                 whereHelpernull_String{field: "\"droplets\".\"sha256_checksum\""},
    BuildGUID:                      whereHelpernull_String{field: "\"droplets\".\"build_guid\""},
    DockerReceiptUsername:          whereHelpernull_String{field: "\"droplets\".\"docker_receipt_username\""},
    DockerReceiptPasswordSalt:      whereHelpernull_String{field: "\"droplets\".\"docker_receipt_password_salt\""},
    EncryptedDockerReceiptPassword: whereHelpernull_String{field: "\"droplets\".\"encrypted_docker_receipt_password\""},
    EncryptionKeyLabel:             whereHelpernull_String{field: "\"droplets\".\"encryption_key_label\""},
    EncryptionIterations:           whereHelperint{field: "\"droplets\".\"encryption_iterations\""},
    Sidecars:                       whereHelpernull_String{field: "\"droplets\".\"sidecars\""},
}
var EncryptionKeySentinelColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    ExpectedValue        string
    EncryptedValue       string
    EncryptionKeyLabel   string
    Salt                 string
    EncryptionIterations string
}{
    ID:                   "id",
    GUID:                 "guid",
    CreatedAt:            "created_at",
    UpdatedAt:            "updated_at",
    ExpectedValue:        "expected_value",
    EncryptedValue:       "encrypted_value",
    EncryptionKeyLabel:   "encryption_key_label",
    Salt:                 "salt",
    EncryptionIterations: "encryption_iterations",
}

EncryptionKeySentinelRels is where relationship names are stored.

var EncryptionKeySentinelRels = struct {
}{}
var EncryptionKeySentinelTableColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    ExpectedValue        string
    EncryptedValue       string
    EncryptionKeyLabel   string
    Salt                 string
    EncryptionIterations string
}{
    ID:                   "encryption_key_sentinels.id",
    GUID:                 "encryption_key_sentinels.guid",
    CreatedAt:            "encryption_key_sentinels.created_at",
    UpdatedAt:            "encryption_key_sentinels.updated_at",
    ExpectedValue:        "encryption_key_sentinels.expected_value",
    EncryptedValue:       "encryption_key_sentinels.encrypted_value",
    EncryptionKeyLabel:   "encryption_key_sentinels.encryption_key_label",
    Salt:                 "encryption_key_sentinels.salt",
    EncryptionIterations: "encryption_key_sentinels.encryption_iterations",
}
var EncryptionKeySentinelWhere = struct {
    ID                   whereHelperint
    GUID                 whereHelperstring
    CreatedAt            whereHelpertime_Time
    UpdatedAt            whereHelpernull_Time
    ExpectedValue        whereHelpernull_String
    EncryptedValue       whereHelpernull_String
    EncryptionKeyLabel   whereHelpernull_String
    Salt                 whereHelpernull_String
    EncryptionIterations whereHelperint
}{
    ID:                   whereHelperint{field: "\"encryption_key_sentinels\".\"id\""},
    GUID:                 whereHelperstring{field: "\"encryption_key_sentinels\".\"guid\""},
    CreatedAt:            whereHelpertime_Time{field: "\"encryption_key_sentinels\".\"created_at\""},
    UpdatedAt:            whereHelpernull_Time{field: "\"encryption_key_sentinels\".\"updated_at\""},
    ExpectedValue:        whereHelpernull_String{field: "\"encryption_key_sentinels\".\"expected_value\""},
    EncryptedValue:       whereHelpernull_String{field: "\"encryption_key_sentinels\".\"encrypted_value\""},
    EncryptionKeyLabel:   whereHelpernull_String{field: "\"encryption_key_sentinels\".\"encryption_key_label\""},
    Salt:                 whereHelpernull_String{field: "\"encryption_key_sentinels\".\"salt\""},
    EncryptionIterations: whereHelperint{field: "\"encryption_key_sentinels\".\"encryption_iterations\""},
}
var EnvGroupColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    EnvironmentJSON      string
    Salt                 string
    EncryptionKeyLabel   string
    EncryptionIterations string
}{
    ID:                   "id",
    GUID:                 "guid",
    CreatedAt:            "created_at",
    UpdatedAt:            "updated_at",
    Name:                 "name",
    EnvironmentJSON:      "environment_json",
    Salt:                 "salt",
    EncryptionKeyLabel:   "encryption_key_label",
    EncryptionIterations: "encryption_iterations",
}

EnvGroupRels is where relationship names are stored.

var EnvGroupRels = struct {
}{}
var EnvGroupTableColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    EnvironmentJSON      string
    Salt                 string
    EncryptionKeyLabel   string
    EncryptionIterations string
}{
    ID:                   "env_groups.id",
    GUID:                 "env_groups.guid",
    CreatedAt:            "env_groups.created_at",
    UpdatedAt:            "env_groups.updated_at",
    Name:                 "env_groups.name",
    EnvironmentJSON:      "env_groups.environment_json",
    Salt:                 "env_groups.salt",
    EncryptionKeyLabel:   "env_groups.encryption_key_label",
    EncryptionIterations: "env_groups.encryption_iterations",
}
var EnvGroupWhere = struct {
    ID                   whereHelperint
    GUID                 whereHelperstring
    CreatedAt            whereHelpertime_Time
    UpdatedAt            whereHelpernull_Time
    Name                 whereHelperstring
    EnvironmentJSON      whereHelpernull_String
    Salt                 whereHelpernull_String
    EncryptionKeyLabel   whereHelpernull_String
    EncryptionIterations whereHelperint
}{
    ID:                   whereHelperint{field: "\"env_groups\".\"id\""},
    GUID:                 whereHelperstring{field: "\"env_groups\".\"guid\""},
    CreatedAt:            whereHelpertime_Time{field: "\"env_groups\".\"created_at\""},
    UpdatedAt:            whereHelpernull_Time{field: "\"env_groups\".\"updated_at\""},
    Name:                 whereHelperstring{field: "\"env_groups\".\"name\""},
    EnvironmentJSON:      whereHelpernull_String{field: "\"env_groups\".\"environment_json\""},
    Salt:                 whereHelpernull_String{field: "\"env_groups\".\"salt\""},
    EncryptionKeyLabel:   whereHelpernull_String{field: "\"env_groups\".\"encryption_key_label\""},
    EncryptionIterations: whereHelperint{field: "\"env_groups\".\"encryption_iterations\""},
}

ErrSyncFail occurs during insert when the record could not be retrieved in order to populate default value information. This usually happens when LastInsertId fails or there was a primary key configuration that was not resolvable.

var ErrSyncFail = errors.New("models: failed to synchronize data after insert")
var EventColumns = struct {
    ID               string
    GUID             string
    CreatedAt        string
    UpdatedAt        string
    Timestamp        string
    Type             string
    Actor            string
    ActorType        string
    Actee            string
    ActeeType        string
    Metadata         string
    OrganizationGUID string
    SpaceGUID        string
    ActorName        string
    ActeeName        string
    ActorUsername    string
}{
    ID:               "id",
    GUID:             "guid",
    CreatedAt:        "created_at",
    UpdatedAt:        "updated_at",
    Timestamp:        "timestamp",
    Type:             "type",
    Actor:            "actor",
    ActorType:        "actor_type",
    Actee:            "actee",
    ActeeType:        "actee_type",
    Metadata:         "metadata",
    OrganizationGUID: "organization_guid",
    SpaceGUID:        "space_guid",
    ActorName:        "actor_name",
    ActeeName:        "actee_name",
    ActorUsername:    "actor_username",
}

EventRels is where relationship names are stored.

var EventRels = struct {
}{}
var EventTableColumns = struct {
    ID               string
    GUID             string
    CreatedAt        string
    UpdatedAt        string
    Timestamp        string
    Type             string
    Actor            string
    ActorType        string
    Actee            string
    ActeeType        string
    Metadata         string
    OrganizationGUID string
    SpaceGUID        string
    ActorName        string
    ActeeName        string
    ActorUsername    string
}{
    ID:               "events.id",
    GUID:             "events.guid",
    CreatedAt:        "events.created_at",
    UpdatedAt:        "events.updated_at",
    Timestamp:        "events.timestamp",
    Type:             "events.type",
    Actor:            "events.actor",
    ActorType:        "events.actor_type",
    Actee:            "events.actee",
    ActeeType:        "events.actee_type",
    Metadata:         "events.metadata",
    OrganizationGUID: "events.organization_guid",
    SpaceGUID:        "events.space_guid",
    ActorName:        "events.actor_name",
    ActeeName:        "events.actee_name",
    ActorUsername:    "events.actor_username",
}
var EventWhere = struct {
    ID               whereHelperint
    GUID             whereHelperstring
    CreatedAt        whereHelpertime_Time
    UpdatedAt        whereHelpernull_Time
    Timestamp        whereHelpertime_Time
    Type             whereHelperstring
    Actor            whereHelperstring
    ActorType        whereHelperstring
    Actee            whereHelperstring
    ActeeType        whereHelperstring
    Metadata         whereHelpernull_String
    OrganizationGUID whereHelperstring
    SpaceGUID        whereHelperstring
    ActorName        whereHelpernull_String
    ActeeName        whereHelpernull_String
    ActorUsername    whereHelpernull_String
}{
    ID:               whereHelperint{field: "\"events\".\"id\""},
    GUID:             whereHelperstring{field: "\"events\".\"guid\""},
    CreatedAt:        whereHelpertime_Time{field: "\"events\".\"created_at\""},
    UpdatedAt:        whereHelpernull_Time{field: "\"events\".\"updated_at\""},
    Timestamp:        whereHelpertime_Time{field: "\"events\".\"timestamp\""},
    Type:             whereHelperstring{field: "\"events\".\"type\""},
    Actor:            whereHelperstring{field: "\"events\".\"actor\""},
    ActorType:        whereHelperstring{field: "\"events\".\"actor_type\""},
    Actee:            whereHelperstring{field: "\"events\".\"actee\""},
    ActeeType:        whereHelperstring{field: "\"events\".\"actee_type\""},
    Metadata:         whereHelpernull_String{field: "\"events\".\"metadata\""},
    OrganizationGUID: whereHelperstring{field: "\"events\".\"organization_guid\""},
    SpaceGUID:        whereHelperstring{field: "\"events\".\"space_guid\""},
    ActorName:        whereHelpernull_String{field: "\"events\".\"actor_name\""},
    ActeeName:        whereHelpernull_String{field: "\"events\".\"actee_name\""},
    ActorUsername:    whereHelpernull_String{field: "\"events\".\"actor_username\""},
}
var FeatureFlagColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    Name         string
    Enabled      string
    ErrorMessage string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    Name:         "name",
    Enabled:      "enabled",
    ErrorMessage: "error_message",
}

FeatureFlagRels is where relationship names are stored.

var FeatureFlagRels = struct {
}{}
var FeatureFlagTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    Name         string
    Enabled      string
    ErrorMessage string
}{
    ID:           "feature_flags.id",
    GUID:         "feature_flags.guid",
    CreatedAt:    "feature_flags.created_at",
    UpdatedAt:    "feature_flags.updated_at",
    Name:         "feature_flags.name",
    Enabled:      "feature_flags.enabled",
    ErrorMessage: "feature_flags.error_message",
}
var FeatureFlagWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    Name         whereHelperstring
    Enabled      whereHelperbool
    ErrorMessage whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"feature_flags\".\"id\""},
    GUID:         whereHelperstring{field: "\"feature_flags\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"feature_flags\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"feature_flags\".\"updated_at\""},
    Name:         whereHelperstring{field: "\"feature_flags\".\"name\""},
    Enabled:      whereHelperbool{field: "\"feature_flags\".\"enabled\""},
    ErrorMessage: whereHelpernull_String{field: "\"feature_flags\".\"error_message\""},
}
var IsolationSegmentAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

IsolationSegmentAnnotationRels is where relationship names are stored.

var IsolationSegmentAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var IsolationSegmentAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "isolation_segment_annotations.id",
    GUID:         "isolation_segment_annotations.guid",
    CreatedAt:    "isolation_segment_annotations.created_at",
    UpdatedAt:    "isolation_segment_annotations.updated_at",
    ResourceGUID: "isolation_segment_annotations.resource_guid",
    KeyPrefix:    "isolation_segment_annotations.key_prefix",
    Key:          "isolation_segment_annotations.key",
    Value:        "isolation_segment_annotations.value",
}
var IsolationSegmentAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"isolation_segment_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"isolation_segment_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"isolation_segment_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"isolation_segment_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"isolation_segment_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"isolation_segment_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"isolation_segment_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"isolation_segment_annotations\".\"value\""},
}
var IsolationSegmentColumns = struct {
    ID        string
    GUID      string
    CreatedAt string
    UpdatedAt string
    Name      string
}{
    ID:        "id",
    GUID:      "guid",
    CreatedAt: "created_at",
    UpdatedAt: "updated_at",
    Name:      "name",
}
var IsolationSegmentLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

IsolationSegmentLabelRels is where relationship names are stored.

var IsolationSegmentLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var IsolationSegmentLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "isolation_segment_labels.id",
    GUID:         "isolation_segment_labels.guid",
    CreatedAt:    "isolation_segment_labels.created_at",
    UpdatedAt:    "isolation_segment_labels.updated_at",
    ResourceGUID: "isolation_segment_labels.resource_guid",
    KeyPrefix:    "isolation_segment_labels.key_prefix",
    KeyName:      "isolation_segment_labels.key_name",
    Value:        "isolation_segment_labels.value",
}
var IsolationSegmentLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"isolation_segment_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"isolation_segment_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"isolation_segment_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"isolation_segment_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"isolation_segment_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"isolation_segment_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"isolation_segment_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"isolation_segment_labels\".\"value\""},
}

IsolationSegmentRels is where relationship names are stored.

var IsolationSegmentRels = struct {
    ResourceIsolationSegmentAnnotations string
    ResourceIsolationSegmentLabels      string
    Organizations                       string
    Spaces                              string
}{
    ResourceIsolationSegmentAnnotations: "ResourceIsolationSegmentAnnotations",
    ResourceIsolationSegmentLabels:      "ResourceIsolationSegmentLabels",
    Organizations:                       "Organizations",
    Spaces:                              "Spaces",
}
var IsolationSegmentTableColumns = struct {
    ID        string
    GUID      string
    CreatedAt string
    UpdatedAt string
    Name      string
}{
    ID:        "isolation_segments.id",
    GUID:      "isolation_segments.guid",
    CreatedAt: "isolation_segments.created_at",
    UpdatedAt: "isolation_segments.updated_at",
    Name:      "isolation_segments.name",
}
var IsolationSegmentWhere = struct {
    ID        whereHelperint
    GUID      whereHelperstring
    CreatedAt whereHelpertime_Time
    UpdatedAt whereHelpernull_Time
    Name      whereHelperstring
}{
    ID:        whereHelperint{field: "\"isolation_segments\".\"id\""},
    GUID:      whereHelperstring{field: "\"isolation_segments\".\"guid\""},
    CreatedAt: whereHelpertime_Time{field: "\"isolation_segments\".\"created_at\""},
    UpdatedAt: whereHelpernull_Time{field: "\"isolation_segments\".\"updated_at\""},
    Name:      whereHelperstring{field: "\"isolation_segments\".\"name\""},
}
var JobColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    State          string
    Operation      string
    ResourceGUID   string
    ResourceType   string
    DelayedJobGUID string
    CFAPIError     string
}{
    ID:             "id",
    GUID:           "guid",
    CreatedAt:      "created_at",
    UpdatedAt:      "updated_at",
    State:          "state",
    Operation:      "operation",
    ResourceGUID:   "resource_guid",
    ResourceType:   "resource_type",
    DelayedJobGUID: "delayed_job_guid",
    CFAPIError:     "cf_api_error",
}

JobRels is where relationship names are stored.

var JobRels = struct {
    FKJobJobWarnings string
}{
    FKJobJobWarnings: "FKJobJobWarnings",
}
var JobTableColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    State          string
    Operation      string
    ResourceGUID   string
    ResourceType   string
    DelayedJobGUID string
    CFAPIError     string
}{
    ID:             "jobs.id",
    GUID:           "jobs.guid",
    CreatedAt:      "jobs.created_at",
    UpdatedAt:      "jobs.updated_at",
    State:          "jobs.state",
    Operation:      "jobs.operation",
    ResourceGUID:   "jobs.resource_guid",
    ResourceType:   "jobs.resource_type",
    DelayedJobGUID: "jobs.delayed_job_guid",
    CFAPIError:     "jobs.cf_api_error",
}
var JobWarningColumns = struct {
    ID        string
    GUID      string
    CreatedAt string
    UpdatedAt string
    Detail    string
    JobID     string
    FKJobsID  string
}{
    ID:        "id",
    GUID:      "guid",
    CreatedAt: "created_at",
    UpdatedAt: "updated_at",
    Detail:    "detail",
    JobID:     "job_id",
    FKJobsID:  "fk_jobs_id",
}

JobWarningRels is where relationship names are stored.

var JobWarningRels = struct {
    FKJob string
}{
    FKJob: "FKJob",
}
var JobWarningTableColumns = struct {
    ID        string
    GUID      string
    CreatedAt string
    UpdatedAt string
    Detail    string
    JobID     string
    FKJobsID  string
}{
    ID:        "job_warnings.id",
    GUID:      "job_warnings.guid",
    CreatedAt: "job_warnings.created_at",
    UpdatedAt: "job_warnings.updated_at",
    Detail:    "job_warnings.detail",
    JobID:     "job_warnings.job_id",
    FKJobsID:  "job_warnings.fk_jobs_id",
}
var JobWarningWhere = struct {
    ID        whereHelperint
    GUID      whereHelperstring
    CreatedAt whereHelpertime_Time
    UpdatedAt whereHelpernull_Time
    Detail    whereHelperstring
    JobID     whereHelperint
    FKJobsID  whereHelpernull_Int
}{
    ID:        whereHelperint{field: "\"job_warnings\".\"id\""},
    GUID:      whereHelperstring{field: "\"job_warnings\".\"guid\""},
    CreatedAt: whereHelpertime_Time{field: "\"job_warnings\".\"created_at\""},
    UpdatedAt: whereHelpernull_Time{field: "\"job_warnings\".\"updated_at\""},
    Detail:    whereHelperstring{field: "\"job_warnings\".\"detail\""},
    JobID:     whereHelperint{field: "\"job_warnings\".\"job_id\""},
    FKJobsID:  whereHelpernull_Int{field: "\"job_warnings\".\"fk_jobs_id\""},
}
var JobWhere = struct {
    ID             whereHelperint
    GUID           whereHelperstring
    CreatedAt      whereHelpertime_Time
    UpdatedAt      whereHelpernull_Time
    State          whereHelpernull_String
    Operation      whereHelpernull_String
    ResourceGUID   whereHelpernull_String
    ResourceType   whereHelpernull_String
    DelayedJobGUID whereHelpernull_String
    CFAPIError     whereHelpernull_String
}{
    ID:             whereHelperint{field: "\"jobs\".\"id\""},
    GUID:           whereHelperstring{field: "\"jobs\".\"guid\""},
    CreatedAt:      whereHelpertime_Time{field: "\"jobs\".\"created_at\""},
    UpdatedAt:      whereHelpernull_Time{field: "\"jobs\".\"updated_at\""},
    State:          whereHelpernull_String{field: "\"jobs\".\"state\""},
    Operation:      whereHelpernull_String{field: "\"jobs\".\"operation\""},
    ResourceGUID:   whereHelpernull_String{field: "\"jobs\".\"resource_guid\""},
    ResourceType:   whereHelpernull_String{field: "\"jobs\".\"resource_type\""},
    DelayedJobGUID: whereHelpernull_String{field: "\"jobs\".\"delayed_job_guid\""},
    CFAPIError:     whereHelpernull_String{field: "\"jobs\".\"cf_api_error\""},
}
var KpackLifecycleDatumColumns = struct {
    ID          string
    GUID        string
    CreatedAt   string
    UpdatedAt   string
    BuildGUID   string
    DropletGUID string
    AppGUID     string
    Buildpacks  string
}{
    ID:          "id",
    GUID:        "guid",
    CreatedAt:   "created_at",
    UpdatedAt:   "updated_at",
    BuildGUID:   "build_guid",
    DropletGUID: "droplet_guid",
    AppGUID:     "app_guid",
    Buildpacks:  "buildpacks",
}

KpackLifecycleDatumRels is where relationship names are stored.

var KpackLifecycleDatumRels = struct {
    App   string
    Build string
}{
    App:   "App",
    Build: "Build",
}
var KpackLifecycleDatumTableColumns = struct {
    ID          string
    GUID        string
    CreatedAt   string
    UpdatedAt   string
    BuildGUID   string
    DropletGUID string
    AppGUID     string
    Buildpacks  string
}{
    ID:          "kpack_lifecycle_data.id",
    GUID:        "kpack_lifecycle_data.guid",
    CreatedAt:   "kpack_lifecycle_data.created_at",
    UpdatedAt:   "kpack_lifecycle_data.updated_at",
    BuildGUID:   "kpack_lifecycle_data.build_guid",
    DropletGUID: "kpack_lifecycle_data.droplet_guid",
    AppGUID:     "kpack_lifecycle_data.app_guid",
    Buildpacks:  "kpack_lifecycle_data.buildpacks",
}
var KpackLifecycleDatumWhere = struct {
    ID          whereHelperint
    GUID        whereHelperstring
    CreatedAt   whereHelpertime_Time
    UpdatedAt   whereHelpernull_Time
    BuildGUID   whereHelpernull_String
    DropletGUID whereHelpernull_String
    AppGUID     whereHelpernull_String
    Buildpacks  whereHelpernull_String
}{
    ID:          whereHelperint{field: "\"kpack_lifecycle_data\".\"id\""},
    GUID:        whereHelperstring{field: "\"kpack_lifecycle_data\".\"guid\""},
    CreatedAt:   whereHelpertime_Time{field: "\"kpack_lifecycle_data\".\"created_at\""},
    UpdatedAt:   whereHelpernull_Time{field: "\"kpack_lifecycle_data\".\"updated_at\""},
    BuildGUID:   whereHelpernull_String{field: "\"kpack_lifecycle_data\".\"build_guid\""},
    DropletGUID: whereHelpernull_String{field: "\"kpack_lifecycle_data\".\"droplet_guid\""},
    AppGUID:     whereHelpernull_String{field: "\"kpack_lifecycle_data\".\"app_guid\""},
    Buildpacks:  whereHelpernull_String{field: "\"kpack_lifecycle_data\".\"buildpacks\""},
}
var LockingColumns = struct {
    ID   string
    Name string
}{
    ID:   "id",
    Name: "name",
}

LockingRels is where relationship names are stored.

var LockingRels = struct {
}{}
var LockingTableColumns = struct {
    ID   string
    Name string
}{
    ID:   "lockings.id",
    Name: "lockings.name",
}
var LockingWhere = struct {
    ID   whereHelperint
    Name whereHelperstring
}{
    ID:   whereHelperint{field: "\"lockings\".\"id\""},
    Name: whereHelperstring{field: "\"lockings\".\"name\""},
}
var OrganizationAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

OrganizationAnnotationRels is where relationship names are stored.

var OrganizationAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var OrganizationAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "organization_annotations.id",
    GUID:         "organization_annotations.guid",
    CreatedAt:    "organization_annotations.created_at",
    UpdatedAt:    "organization_annotations.updated_at",
    ResourceGUID: "organization_annotations.resource_guid",
    KeyPrefix:    "organization_annotations.key_prefix",
    Key:          "organization_annotations.key",
    Value:        "organization_annotations.value",
}
var OrganizationAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"organization_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"organization_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"organization_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"organization_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"organization_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"organization_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"organization_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"organization_annotations\".\"value\""},
}
var OrganizationColumns = struct {
    ID                          string
    GUID                        string
    CreatedAt                   string
    UpdatedAt                   string
    Name                        string
    BillingEnabled              string
    QuotaDefinitionID           string
    Status                      string
    DefaultIsolationSegmentGUID string
}{
    ID:                          "id",
    GUID:                        "guid",
    CreatedAt:                   "created_at",
    UpdatedAt:                   "updated_at",
    Name:                        "name",
    BillingEnabled:              "billing_enabled",
    QuotaDefinitionID:           "quota_definition_id",
    Status:                      "status",
    DefaultIsolationSegmentGUID: "default_isolation_segment_guid",
}
var OrganizationLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

OrganizationLabelRels is where relationship names are stored.

var OrganizationLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var OrganizationLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "organization_labels.id",
    GUID:         "organization_labels.guid",
    CreatedAt:    "organization_labels.created_at",
    UpdatedAt:    "organization_labels.updated_at",
    ResourceGUID: "organization_labels.resource_guid",
    KeyPrefix:    "organization_labels.key_prefix",
    KeyName:      "organization_labels.key_name",
    Value:        "organization_labels.value",
}
var OrganizationLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"organization_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"organization_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"organization_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"organization_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"organization_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"organization_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"organization_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"organization_labels\".\"value\""},
}

OrganizationRels is where relationship names are stored.

var OrganizationRels = struct {
    QuotaDefinition                 string
    OwningOrganizationDomains       string
    ResourceOrganizationAnnotations string
    ResourceOrganizationLabels      string
    OrganizationsAuditors           string
    OrganizationsBillingManagers    string
    IsolationSegments               string
    OrganizationsManagers           string
    OrganizationsPrivateDomains     string
    OrganizationsUsers              string
    ServicePlanVisibilities         string
    SpaceQuotaDefinitions           string
    Spaces                          string
}{
    QuotaDefinition:                 "QuotaDefinition",
    OwningOrganizationDomains:       "OwningOrganizationDomains",
    ResourceOrganizationAnnotations: "ResourceOrganizationAnnotations",
    ResourceOrganizationLabels:      "ResourceOrganizationLabels",
    OrganizationsAuditors:           "OrganizationsAuditors",
    OrganizationsBillingManagers:    "OrganizationsBillingManagers",
    IsolationSegments:               "IsolationSegments",
    OrganizationsManagers:           "OrganizationsManagers",
    OrganizationsPrivateDomains:     "OrganizationsPrivateDomains",
    OrganizationsUsers:              "OrganizationsUsers",
    ServicePlanVisibilities:         "ServicePlanVisibilities",
    SpaceQuotaDefinitions:           "SpaceQuotaDefinitions",
    Spaces:                          "Spaces",
}
var OrganizationTableColumns = struct {
    ID                          string
    GUID                        string
    CreatedAt                   string
    UpdatedAt                   string
    Name                        string
    BillingEnabled              string
    QuotaDefinitionID           string
    Status                      string
    DefaultIsolationSegmentGUID string
}{
    ID:                          "organizations.id",
    GUID:                        "organizations.guid",
    CreatedAt:                   "organizations.created_at",
    UpdatedAt:                   "organizations.updated_at",
    Name:                        "organizations.name",
    BillingEnabled:              "organizations.billing_enabled",
    QuotaDefinitionID:           "organizations.quota_definition_id",
    Status:                      "organizations.status",
    DefaultIsolationSegmentGUID: "organizations.default_isolation_segment_guid",
}
var OrganizationWhere = struct {
    ID                          whereHelperint
    GUID                        whereHelperstring
    CreatedAt                   whereHelpertime_Time
    UpdatedAt                   whereHelpernull_Time
    Name                        whereHelperstring
    BillingEnabled              whereHelperbool
    QuotaDefinitionID           whereHelperint
    Status                      whereHelpernull_String
    DefaultIsolationSegmentGUID whereHelpernull_String
}{
    ID:                          whereHelperint{field: "\"organizations\".\"id\""},
    GUID:                        whereHelperstring{field: "\"organizations\".\"guid\""},
    CreatedAt:                   whereHelpertime_Time{field: "\"organizations\".\"created_at\""},
    UpdatedAt:                   whereHelpernull_Time{field: "\"organizations\".\"updated_at\""},
    Name:                        whereHelperstring{field: "\"organizations\".\"name\""},
    BillingEnabled:              whereHelperbool{field: "\"organizations\".\"billing_enabled\""},
    QuotaDefinitionID:           whereHelperint{field: "\"organizations\".\"quota_definition_id\""},
    Status:                      whereHelpernull_String{field: "\"organizations\".\"status\""},
    DefaultIsolationSegmentGUID: whereHelpernull_String{field: "\"organizations\".\"default_isolation_segment_guid\""},
}
var OrganizationsAuditorColumns = struct {
    OrganizationID          string
    UserID                  string
    OrganizationsAuditorsPK string
    RoleGUID                string
    CreatedAt               string
    UpdatedAt               string
}{
    OrganizationID:          "organization_id",
    UserID:                  "user_id",
    OrganizationsAuditorsPK: "organizations_auditors_pk",
    RoleGUID:                "role_guid",
    CreatedAt:               "created_at",
    UpdatedAt:               "updated_at",
}

OrganizationsAuditorRels is where relationship names are stored.

var OrganizationsAuditorRels = struct {
    Organization string
    User         string
}{
    Organization: "Organization",
    User:         "User",
}
var OrganizationsAuditorTableColumns = struct {
    OrganizationID          string
    UserID                  string
    OrganizationsAuditorsPK string
    RoleGUID                string
    CreatedAt               string
    UpdatedAt               string
}{
    OrganizationID:          "organizations_auditors.organization_id",
    UserID:                  "organizations_auditors.user_id",
    OrganizationsAuditorsPK: "organizations_auditors.organizations_auditors_pk",
    RoleGUID:                "organizations_auditors.role_guid",
    CreatedAt:               "organizations_auditors.created_at",
    UpdatedAt:               "organizations_auditors.updated_at",
}
var OrganizationsAuditorWhere = struct {
    OrganizationID          whereHelperint
    UserID                  whereHelperint
    OrganizationsAuditorsPK whereHelperint
    RoleGUID                whereHelpernull_String
    CreatedAt               whereHelpertime_Time
    UpdatedAt               whereHelpertime_Time
}{
    OrganizationID:          whereHelperint{field: "\"organizations_auditors\".\"organization_id\""},
    UserID:                  whereHelperint{field: "\"organizations_auditors\".\"user_id\""},
    OrganizationsAuditorsPK: whereHelperint{field: "\"organizations_auditors\".\"organizations_auditors_pk\""},
    RoleGUID:                whereHelpernull_String{field: "\"organizations_auditors\".\"role_guid\""},
    CreatedAt:               whereHelpertime_Time{field: "\"organizations_auditors\".\"created_at\""},
    UpdatedAt:               whereHelpertime_Time{field: "\"organizations_auditors\".\"updated_at\""},
}
var OrganizationsBillingManagerColumns = struct {
    OrganizationID                 string
    UserID                         string
    OrganizationsBillingManagersPK string
    RoleGUID                       string
    CreatedAt                      string
    UpdatedAt                      string
}{
    OrganizationID:                 "organization_id",
    UserID:                         "user_id",
    OrganizationsBillingManagersPK: "organizations_billing_managers_pk",
    RoleGUID:                       "role_guid",
    CreatedAt:                      "created_at",
    UpdatedAt:                      "updated_at",
}

OrganizationsBillingManagerRels is where relationship names are stored.

var OrganizationsBillingManagerRels = struct {
    Organization string
    User         string
}{
    Organization: "Organization",
    User:         "User",
}
var OrganizationsBillingManagerTableColumns = struct {
    OrganizationID                 string
    UserID                         string
    OrganizationsBillingManagersPK string
    RoleGUID                       string
    CreatedAt                      string
    UpdatedAt                      string
}{
    OrganizationID:                 "organizations_billing_managers.organization_id",
    UserID:                         "organizations_billing_managers.user_id",
    OrganizationsBillingManagersPK: "organizations_billing_managers.organizations_billing_managers_pk",
    RoleGUID:                       "organizations_billing_managers.role_guid",
    CreatedAt:                      "organizations_billing_managers.created_at",
    UpdatedAt:                      "organizations_billing_managers.updated_at",
}
var OrganizationsBillingManagerWhere = struct {
    OrganizationID                 whereHelperint
    UserID                         whereHelperint
    OrganizationsBillingManagersPK whereHelperint
    RoleGUID                       whereHelpernull_String
    CreatedAt                      whereHelpertime_Time
    UpdatedAt                      whereHelpertime_Time
}{
    OrganizationID:                 whereHelperint{field: "\"organizations_billing_managers\".\"organization_id\""},
    UserID:                         whereHelperint{field: "\"organizations_billing_managers\".\"user_id\""},
    OrganizationsBillingManagersPK: whereHelperint{field: "\"organizations_billing_managers\".\"organizations_billing_managers_pk\""},
    RoleGUID:                       whereHelpernull_String{field: "\"organizations_billing_managers\".\"role_guid\""},
    CreatedAt:                      whereHelpertime_Time{field: "\"organizations_billing_managers\".\"created_at\""},
    UpdatedAt:                      whereHelpertime_Time{field: "\"organizations_billing_managers\".\"updated_at\""},
}
var OrganizationsManagerColumns = struct {
    OrganizationID          string
    UserID                  string
    OrganizationsManagersPK string
    RoleGUID                string
    CreatedAt               string
    UpdatedAt               string
}{
    OrganizationID:          "organization_id",
    UserID:                  "user_id",
    OrganizationsManagersPK: "organizations_managers_pk",
    RoleGUID:                "role_guid",
    CreatedAt:               "created_at",
    UpdatedAt:               "updated_at",
}

OrganizationsManagerRels is where relationship names are stored.

var OrganizationsManagerRels = struct {
    Organization string
    User         string
}{
    Organization: "Organization",
    User:         "User",
}
var OrganizationsManagerTableColumns = struct {
    OrganizationID          string
    UserID                  string
    OrganizationsManagersPK string
    RoleGUID                string
    CreatedAt               string
    UpdatedAt               string
}{
    OrganizationID:          "organizations_managers.organization_id",
    UserID:                  "organizations_managers.user_id",
    OrganizationsManagersPK: "organizations_managers.organizations_managers_pk",
    RoleGUID:                "organizations_managers.role_guid",
    CreatedAt:               "organizations_managers.created_at",
    UpdatedAt:               "organizations_managers.updated_at",
}
var OrganizationsManagerWhere = struct {
    OrganizationID          whereHelperint
    UserID                  whereHelperint
    OrganizationsManagersPK whereHelperint
    RoleGUID                whereHelpernull_String
    CreatedAt               whereHelpertime_Time
    UpdatedAt               whereHelpertime_Time
}{
    OrganizationID:          whereHelperint{field: "\"organizations_managers\".\"organization_id\""},
    UserID:                  whereHelperint{field: "\"organizations_managers\".\"user_id\""},
    OrganizationsManagersPK: whereHelperint{field: "\"organizations_managers\".\"organizations_managers_pk\""},
    RoleGUID:                whereHelpernull_String{field: "\"organizations_managers\".\"role_guid\""},
    CreatedAt:               whereHelpertime_Time{field: "\"organizations_managers\".\"created_at\""},
    UpdatedAt:               whereHelpertime_Time{field: "\"organizations_managers\".\"updated_at\""},
}
var OrganizationsPrivateDomainColumns = struct {
    OrganizationID                string
    PrivateDomainID               string
    OrganizationsPrivateDomainsPK string
}{
    OrganizationID:                "organization_id",
    PrivateDomainID:               "private_domain_id",
    OrganizationsPrivateDomainsPK: "organizations_private_domains_pk",
}

OrganizationsPrivateDomainRels is where relationship names are stored.

var OrganizationsPrivateDomainRels = struct {
    Organization  string
    PrivateDomain string
}{
    Organization:  "Organization",
    PrivateDomain: "PrivateDomain",
}
var OrganizationsPrivateDomainTableColumns = struct {
    OrganizationID                string
    PrivateDomainID               string
    OrganizationsPrivateDomainsPK string
}{
    OrganizationID:                "organizations_private_domains.organization_id",
    PrivateDomainID:               "organizations_private_domains.private_domain_id",
    OrganizationsPrivateDomainsPK: "organizations_private_domains.organizations_private_domains_pk",
}
var OrganizationsPrivateDomainWhere = struct {
    OrganizationID                whereHelperint
    PrivateDomainID               whereHelperint
    OrganizationsPrivateDomainsPK whereHelperint
}{
    OrganizationID:                whereHelperint{field: "\"organizations_private_domains\".\"organization_id\""},
    PrivateDomainID:               whereHelperint{field: "\"organizations_private_domains\".\"private_domain_id\""},
    OrganizationsPrivateDomainsPK: whereHelperint{field: "\"organizations_private_domains\".\"organizations_private_domains_pk\""},
}
var OrganizationsUserColumns = struct {
    OrganizationID       string
    UserID               string
    OrganizationsUsersPK string
    RoleGUID             string
    CreatedAt            string
    UpdatedAt            string
}{
    OrganizationID:       "organization_id",
    UserID:               "user_id",
    OrganizationsUsersPK: "organizations_users_pk",
    RoleGUID:             "role_guid",
    CreatedAt:            "created_at",
    UpdatedAt:            "updated_at",
}

OrganizationsUserRels is where relationship names are stored.

var OrganizationsUserRels = struct {
    Organization string
    User         string
}{
    Organization: "Organization",
    User:         "User",
}
var OrganizationsUserTableColumns = struct {
    OrganizationID       string
    UserID               string
    OrganizationsUsersPK string
    RoleGUID             string
    CreatedAt            string
    UpdatedAt            string
}{
    OrganizationID:       "organizations_users.organization_id",
    UserID:               "organizations_users.user_id",
    OrganizationsUsersPK: "organizations_users.organizations_users_pk",
    RoleGUID:             "organizations_users.role_guid",
    CreatedAt:            "organizations_users.created_at",
    UpdatedAt:            "organizations_users.updated_at",
}
var OrganizationsUserWhere = struct {
    OrganizationID       whereHelperint
    UserID               whereHelperint
    OrganizationsUsersPK whereHelperint
    RoleGUID             whereHelpernull_String
    CreatedAt            whereHelpertime_Time
    UpdatedAt            whereHelpertime_Time
}{
    OrganizationID:       whereHelperint{field: "\"organizations_users\".\"organization_id\""},
    UserID:               whereHelperint{field: "\"organizations_users\".\"user_id\""},
    OrganizationsUsersPK: whereHelperint{field: "\"organizations_users\".\"organizations_users_pk\""},
    RoleGUID:             whereHelpernull_String{field: "\"organizations_users\".\"role_guid\""},
    CreatedAt:            whereHelpertime_Time{field: "\"organizations_users\".\"created_at\""},
    UpdatedAt:            whereHelpertime_Time{field: "\"organizations_users\".\"updated_at\""},
}
var OrphanedBlobColumns = struct {
    ID            string
    GUID          string
    CreatedAt     string
    UpdatedAt     string
    BlobKey       string
    DirtyCount    string
    BlobstoreType string
}{
    ID:            "id",
    GUID:          "guid",
    CreatedAt:     "created_at",
    UpdatedAt:     "updated_at",
    BlobKey:       "blob_key",
    DirtyCount:    "dirty_count",
    BlobstoreType: "blobstore_type",
}

OrphanedBlobRels is where relationship names are stored.

var OrphanedBlobRels = struct {
}{}
var OrphanedBlobTableColumns = struct {
    ID            string
    GUID          string
    CreatedAt     string
    UpdatedAt     string
    BlobKey       string
    DirtyCount    string
    BlobstoreType string
}{
    ID:            "orphaned_blobs.id",
    GUID:          "orphaned_blobs.guid",
    CreatedAt:     "orphaned_blobs.created_at",
    UpdatedAt:     "orphaned_blobs.updated_at",
    BlobKey:       "orphaned_blobs.blob_key",
    DirtyCount:    "orphaned_blobs.dirty_count",
    BlobstoreType: "orphaned_blobs.blobstore_type",
}
var OrphanedBlobWhere = struct {
    ID            whereHelperint
    GUID          whereHelperstring
    CreatedAt     whereHelpertime_Time
    UpdatedAt     whereHelpernull_Time
    BlobKey       whereHelpernull_String
    DirtyCount    whereHelpernull_Int
    BlobstoreType whereHelpernull_String
}{
    ID:            whereHelperint{field: "\"orphaned_blobs\".\"id\""},
    GUID:          whereHelperstring{field: "\"orphaned_blobs\".\"guid\""},
    CreatedAt:     whereHelpertime_Time{field: "\"orphaned_blobs\".\"created_at\""},
    UpdatedAt:     whereHelpernull_Time{field: "\"orphaned_blobs\".\"updated_at\""},
    BlobKey:       whereHelpernull_String{field: "\"orphaned_blobs\".\"blob_key\""},
    DirtyCount:    whereHelpernull_Int{field: "\"orphaned_blobs\".\"dirty_count\""},
    BlobstoreType: whereHelpernull_String{field: "\"orphaned_blobs\".\"blobstore_type\""},
}
var PackageAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

PackageAnnotationRels is where relationship names are stored.

var PackageAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var PackageAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "package_annotations.id",
    GUID:         "package_annotations.guid",
    CreatedAt:    "package_annotations.created_at",
    UpdatedAt:    "package_annotations.updated_at",
    ResourceGUID: "package_annotations.resource_guid",
    KeyPrefix:    "package_annotations.key_prefix",
    Key:          "package_annotations.key",
    Value:        "package_annotations.value",
}
var PackageAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"package_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"package_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"package_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"package_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"package_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"package_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"package_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"package_annotations\".\"value\""},
}
var PackageColumns = struct {
    ID                      string
    GUID                    string
    CreatedAt               string
    UpdatedAt               string
    Type                    string
    PackageHash             string
    State                   string
    Error                   string
    AppGUID                 string
    DockerImage             string
    Sha256Checksum          string
    DockerUsername          string
    DockerPasswordSalt      string
    EncryptedDockerPassword string
    EncryptionKeyLabel      string
    EncryptionIterations    string
}{
    ID:                      "id",
    GUID:                    "guid",
    CreatedAt:               "created_at",
    UpdatedAt:               "updated_at",
    Type:                    "type",
    PackageHash:             "package_hash",
    State:                   "state",
    Error:                   "error",
    AppGUID:                 "app_guid",
    DockerImage:             "docker_image",
    Sha256Checksum:          "sha256_checksum",
    DockerUsername:          "docker_username",
    DockerPasswordSalt:      "docker_password_salt",
    EncryptedDockerPassword: "encrypted_docker_password",
    EncryptionKeyLabel:      "encryption_key_label",
    EncryptionIterations:    "encryption_iterations",
}
var PackageLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

PackageLabelRels is where relationship names are stored.

var PackageLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var PackageLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "package_labels.id",
    GUID:         "package_labels.guid",
    CreatedAt:    "package_labels.created_at",
    UpdatedAt:    "package_labels.updated_at",
    ResourceGUID: "package_labels.resource_guid",
    KeyPrefix:    "package_labels.key_prefix",
    KeyName:      "package_labels.key_name",
    Value:        "package_labels.value",
}
var PackageLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"package_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"package_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"package_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"package_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"package_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"package_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"package_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"package_labels\".\"value\""},
}

PackageRels is where relationship names are stored.

var PackageRels = struct {
    App                        string
    ResourcePackageAnnotations string
    ResourcePackageLabels      string
}{
    App:                        "App",
    ResourcePackageAnnotations: "ResourcePackageAnnotations",
    ResourcePackageLabels:      "ResourcePackageLabels",
}
var PackageTableColumns = struct {
    ID                      string
    GUID                    string
    CreatedAt               string
    UpdatedAt               string
    Type                    string
    PackageHash             string
    State                   string
    Error                   string
    AppGUID                 string
    DockerImage             string
    Sha256Checksum          string
    DockerUsername          string
    DockerPasswordSalt      string
    EncryptedDockerPassword string
    EncryptionKeyLabel      string
    EncryptionIterations    string
}{
    ID:                      "packages.id",
    GUID:                    "packages.guid",
    CreatedAt:               "packages.created_at",
    UpdatedAt:               "packages.updated_at",
    Type:                    "packages.type",
    PackageHash:             "packages.package_hash",
    State:                   "packages.state",
    Error:                   "packages.error",
    AppGUID:                 "packages.app_guid",
    DockerImage:             "packages.docker_image",
    Sha256Checksum:          "packages.sha256_checksum",
    DockerUsername:          "packages.docker_username",
    DockerPasswordSalt:      "packages.docker_password_salt",
    EncryptedDockerPassword: "packages.encrypted_docker_password",
    EncryptionKeyLabel:      "packages.encryption_key_label",
    EncryptionIterations:    "packages.encryption_iterations",
}
var PackageWhere = struct {
    ID                      whereHelperint
    GUID                    whereHelperstring
    CreatedAt               whereHelpertime_Time
    UpdatedAt               whereHelpernull_Time
    Type                    whereHelpernull_String
    PackageHash             whereHelpernull_String
    State                   whereHelperstring
    Error                   whereHelpernull_String
    AppGUID                 whereHelpernull_String
    DockerImage             whereHelpernull_String
    Sha256Checksum          whereHelpernull_String
    DockerUsername          whereHelpernull_String
    DockerPasswordSalt      whereHelpernull_String
    EncryptedDockerPassword whereHelpernull_String
    EncryptionKeyLabel      whereHelpernull_String
    EncryptionIterations    whereHelperint
}{
    ID:                      whereHelperint{field: "\"packages\".\"id\""},
    GUID:                    whereHelperstring{field: "\"packages\".\"guid\""},
    CreatedAt:               whereHelpertime_Time{field: "\"packages\".\"created_at\""},
    UpdatedAt:               whereHelpernull_Time{field: "\"packages\".\"updated_at\""},
    Type:                    whereHelpernull_String{field: "\"packages\".\"type\""},
    PackageHash:             whereHelpernull_String{field: "\"packages\".\"package_hash\""},
    State:                   whereHelperstring{field: "\"packages\".\"state\""},
    Error:                   whereHelpernull_String{field: "\"packages\".\"error\""},
    AppGUID:                 whereHelpernull_String{field: "\"packages\".\"app_guid\""},
    DockerImage:             whereHelpernull_String{field: "\"packages\".\"docker_image\""},
    Sha256Checksum:          whereHelpernull_String{field: "\"packages\".\"sha256_checksum\""},
    DockerUsername:          whereHelpernull_String{field: "\"packages\".\"docker_username\""},
    DockerPasswordSalt:      whereHelpernull_String{field: "\"packages\".\"docker_password_salt\""},
    EncryptedDockerPassword: whereHelpernull_String{field: "\"packages\".\"encrypted_docker_password\""},
    EncryptionKeyLabel:      whereHelpernull_String{field: "\"packages\".\"encryption_key_label\""},
    EncryptionIterations:    whereHelperint{field: "\"packages\".\"encryption_iterations\""},
}
var ProcessAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

ProcessAnnotationRels is where relationship names are stored.

var ProcessAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ProcessAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "process_annotations.id",
    GUID:         "process_annotations.guid",
    CreatedAt:    "process_annotations.created_at",
    UpdatedAt:    "process_annotations.updated_at",
    ResourceGUID: "process_annotations.resource_guid",
    KeyPrefix:    "process_annotations.key_prefix",
    Key:          "process_annotations.key",
    Value:        "process_annotations.value",
}
var ProcessAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"process_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"process_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"process_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"process_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"process_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"process_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"process_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"process_annotations\".\"value\""},
}
var ProcessColumns = struct {
    ID                             string
    GUID                           string
    CreatedAt                      string
    UpdatedAt                      string
    Production                     string
    Memory                         string
    Instances                      string
    FileDescriptors                string
    DiskQuota                      string
    State                          string
    Version                        string
    Metadata                       string
    DetectedBuildpack              string
    NotDeleted                     string
    HealthCheckTimeout             string
    Diego                          string
    PackageUpdatedAt               string
    AppGUID                        string
    Type                           string
    HealthCheckType                string
    Command                        string
    EnableSSH                      string
    EncryptedDockerCredentialsJSON string
    DockerSalt                     string
    Ports                          string
    HealthCheckHTTPEndpoint        string
    HealthCheckInvocationTimeout   string
    RevisionGUID                   string
}{
    ID:                             "id",
    GUID:                           "guid",
    CreatedAt:                      "created_at",
    UpdatedAt:                      "updated_at",
    Production:                     "production",
    Memory:                         "memory",
    Instances:                      "instances",
    FileDescriptors:                "file_descriptors",
    DiskQuota:                      "disk_quota",
    State:                          "state",
    Version:                        "version",
    Metadata:                       "metadata",
    DetectedBuildpack:              "detected_buildpack",
    NotDeleted:                     "not_deleted",
    HealthCheckTimeout:             "health_check_timeout",
    Diego:                          "diego",
    PackageUpdatedAt:               "package_updated_at",
    AppGUID:                        "app_guid",
    Type:                           "type",
    HealthCheckType:                "health_check_type",
    Command:                        "command",
    EnableSSH:                      "enable_ssh",
    EncryptedDockerCredentialsJSON: "encrypted_docker_credentials_json",
    DockerSalt:                     "docker_salt",
    Ports:                          "ports",
    HealthCheckHTTPEndpoint:        "health_check_http_endpoint",
    HealthCheckInvocationTimeout:   "health_check_invocation_timeout",
    RevisionGUID:                   "revision_guid",
}
var ProcessLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

ProcessLabelRels is where relationship names are stored.

var ProcessLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ProcessLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "process_labels.id",
    GUID:         "process_labels.guid",
    CreatedAt:    "process_labels.created_at",
    UpdatedAt:    "process_labels.updated_at",
    ResourceGUID: "process_labels.resource_guid",
    KeyPrefix:    "process_labels.key_prefix",
    KeyName:      "process_labels.key_name",
    Value:        "process_labels.value",
}
var ProcessLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"process_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"process_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"process_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"process_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"process_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"process_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"process_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"process_labels\".\"value\""},
}

ProcessRels is where relationship names are stored.

var ProcessRels = struct {
    App                        string
    AppAppEvents               string
    ResourceProcessAnnotations string
    ResourceProcessLabels      string
}{
    App:                        "App",
    AppAppEvents:               "AppAppEvents",
    ResourceProcessAnnotations: "ResourceProcessAnnotations",
    ResourceProcessLabels:      "ResourceProcessLabels",
}
var ProcessTableColumns = struct {
    ID                             string
    GUID                           string
    CreatedAt                      string
    UpdatedAt                      string
    Production                     string
    Memory                         string
    Instances                      string
    FileDescriptors                string
    DiskQuota                      string
    State                          string
    Version                        string
    Metadata                       string
    DetectedBuildpack              string
    NotDeleted                     string
    HealthCheckTimeout             string
    Diego                          string
    PackageUpdatedAt               string
    AppGUID                        string
    Type                           string
    HealthCheckType                string
    Command                        string
    EnableSSH                      string
    EncryptedDockerCredentialsJSON string
    DockerSalt                     string
    Ports                          string
    HealthCheckHTTPEndpoint        string
    HealthCheckInvocationTimeout   string
    RevisionGUID                   string
}{
    ID:                             "processes.id",
    GUID:                           "processes.guid",
    CreatedAt:                      "processes.created_at",
    UpdatedAt:                      "processes.updated_at",
    Production:                     "processes.production",
    Memory:                         "processes.memory",
    Instances:                      "processes.instances",
    FileDescriptors:                "processes.file_descriptors",
    DiskQuota:                      "processes.disk_quota",
    State:                          "processes.state",
    Version:                        "processes.version",
    Metadata:                       "processes.metadata",
    DetectedBuildpack:              "processes.detected_buildpack",
    NotDeleted:                     "processes.not_deleted",
    HealthCheckTimeout:             "processes.health_check_timeout",
    Diego:                          "processes.diego",
    PackageUpdatedAt:               "processes.package_updated_at",
    AppGUID:                        "processes.app_guid",
    Type:                           "processes.type",
    HealthCheckType:                "processes.health_check_type",
    Command:                        "processes.command",
    EnableSSH:                      "processes.enable_ssh",
    EncryptedDockerCredentialsJSON: "processes.encrypted_docker_credentials_json",
    DockerSalt:                     "processes.docker_salt",
    Ports:                          "processes.ports",
    HealthCheckHTTPEndpoint:        "processes.health_check_http_endpoint",
    HealthCheckInvocationTimeout:   "processes.health_check_invocation_timeout",
    RevisionGUID:                   "processes.revision_guid",
}
var ProcessWhere = struct {
    ID                             whereHelperint
    GUID                           whereHelperstring
    CreatedAt                      whereHelpertime_Time
    UpdatedAt                      whereHelpernull_Time
    Production                     whereHelpernull_Bool
    Memory                         whereHelpernull_Int
    Instances                      whereHelpernull_Int
    FileDescriptors                whereHelpernull_Int
    DiskQuota                      whereHelpernull_Int
    State                          whereHelperstring
    Version                        whereHelpernull_String
    Metadata                       whereHelperstring
    DetectedBuildpack              whereHelpernull_String
    NotDeleted                     whereHelpernull_Bool
    HealthCheckTimeout             whereHelpernull_Int
    Diego                          whereHelpernull_Bool
    PackageUpdatedAt               whereHelpernull_Time
    AppGUID                        whereHelpernull_String
    Type                           whereHelpernull_String
    HealthCheckType                whereHelpernull_String
    Command                        whereHelpernull_String
    EnableSSH                      whereHelpernull_Bool
    EncryptedDockerCredentialsJSON whereHelpernull_String
    DockerSalt                     whereHelpernull_String
    Ports                          whereHelpernull_String
    HealthCheckHTTPEndpoint        whereHelpernull_String
    HealthCheckInvocationTimeout   whereHelpernull_Int
    RevisionGUID                   whereHelpernull_String
}{
    ID:                             whereHelperint{field: "\"processes\".\"id\""},
    GUID:                           whereHelperstring{field: "\"processes\".\"guid\""},
    CreatedAt:                      whereHelpertime_Time{field: "\"processes\".\"created_at\""},
    UpdatedAt:                      whereHelpernull_Time{field: "\"processes\".\"updated_at\""},
    Production:                     whereHelpernull_Bool{field: "\"processes\".\"production\""},
    Memory:                         whereHelpernull_Int{field: "\"processes\".\"memory\""},
    Instances:                      whereHelpernull_Int{field: "\"processes\".\"instances\""},
    FileDescriptors:                whereHelpernull_Int{field: "\"processes\".\"file_descriptors\""},
    DiskQuota:                      whereHelpernull_Int{field: "\"processes\".\"disk_quota\""},
    State:                          whereHelperstring{field: "\"processes\".\"state\""},
    Version:                        whereHelpernull_String{field: "\"processes\".\"version\""},
    Metadata:                       whereHelperstring{field: "\"processes\".\"metadata\""},
    DetectedBuildpack:              whereHelpernull_String{field: "\"processes\".\"detected_buildpack\""},
    NotDeleted:                     whereHelpernull_Bool{field: "\"processes\".\"not_deleted\""},
    HealthCheckTimeout:             whereHelpernull_Int{field: "\"processes\".\"health_check_timeout\""},
    Diego:                          whereHelpernull_Bool{field: "\"processes\".\"diego\""},
    PackageUpdatedAt:               whereHelpernull_Time{field: "\"processes\".\"package_updated_at\""},
    AppGUID:                        whereHelpernull_String{field: "\"processes\".\"app_guid\""},
    Type:                           whereHelpernull_String{field: "\"processes\".\"type\""},
    HealthCheckType:                whereHelpernull_String{field: "\"processes\".\"health_check_type\""},
    Command:                        whereHelpernull_String{field: "\"processes\".\"command\""},
    EnableSSH:                      whereHelpernull_Bool{field: "\"processes\".\"enable_ssh\""},
    EncryptedDockerCredentialsJSON: whereHelpernull_String{field: "\"processes\".\"encrypted_docker_credentials_json\""},
    DockerSalt:                     whereHelpernull_String{field: "\"processes\".\"docker_salt\""},
    Ports:                          whereHelpernull_String{field: "\"processes\".\"ports\""},
    HealthCheckHTTPEndpoint:        whereHelpernull_String{field: "\"processes\".\"health_check_http_endpoint\""},
    HealthCheckInvocationTimeout:   whereHelpernull_Int{field: "\"processes\".\"health_check_invocation_timeout\""},
    RevisionGUID:                   whereHelpernull_String{field: "\"processes\".\"revision_guid\""},
}
var QuotaDefinitionColumns = struct {
    ID                      string
    GUID                    string
    CreatedAt               string
    UpdatedAt               string
    Name                    string
    NonBasicServicesAllowed string
    TotalServices           string
    MemoryLimit             string
    TotalRoutes             string
    InstanceMemoryLimit     string
    TotalPrivateDomains     string
    AppInstanceLimit        string
    AppTaskLimit            string
    TotalServiceKeys        string
    TotalReservedRoutePorts string
}{
    ID:                      "id",
    GUID:                    "guid",
    CreatedAt:               "created_at",
    UpdatedAt:               "updated_at",
    Name:                    "name",
    NonBasicServicesAllowed: "non_basic_services_allowed",
    TotalServices:           "total_services",
    MemoryLimit:             "memory_limit",
    TotalRoutes:             "total_routes",
    InstanceMemoryLimit:     "instance_memory_limit",
    TotalPrivateDomains:     "total_private_domains",
    AppInstanceLimit:        "app_instance_limit",
    AppTaskLimit:            "app_task_limit",
    TotalServiceKeys:        "total_service_keys",
    TotalReservedRoutePorts: "total_reserved_route_ports",
}

QuotaDefinitionRels is where relationship names are stored.

var QuotaDefinitionRels = struct {
    Organizations string
}{
    Organizations: "Organizations",
}
var QuotaDefinitionTableColumns = struct {
    ID                      string
    GUID                    string
    CreatedAt               string
    UpdatedAt               string
    Name                    string
    NonBasicServicesAllowed string
    TotalServices           string
    MemoryLimit             string
    TotalRoutes             string
    InstanceMemoryLimit     string
    TotalPrivateDomains     string
    AppInstanceLimit        string
    AppTaskLimit            string
    TotalServiceKeys        string
    TotalReservedRoutePorts string
}{
    ID:                      "quota_definitions.id",
    GUID:                    "quota_definitions.guid",
    CreatedAt:               "quota_definitions.created_at",
    UpdatedAt:               "quota_definitions.updated_at",
    Name:                    "quota_definitions.name",
    NonBasicServicesAllowed: "quota_definitions.non_basic_services_allowed",
    TotalServices:           "quota_definitions.total_services",
    MemoryLimit:             "quota_definitions.memory_limit",
    TotalRoutes:             "quota_definitions.total_routes",
    InstanceMemoryLimit:     "quota_definitions.instance_memory_limit",
    TotalPrivateDomains:     "quota_definitions.total_private_domains",
    AppInstanceLimit:        "quota_definitions.app_instance_limit",
    AppTaskLimit:            "quota_definitions.app_task_limit",
    TotalServiceKeys:        "quota_definitions.total_service_keys",
    TotalReservedRoutePorts: "quota_definitions.total_reserved_route_ports",
}
var QuotaDefinitionWhere = struct {
    ID                      whereHelperint
    GUID                    whereHelperstring
    CreatedAt               whereHelpertime_Time
    UpdatedAt               whereHelpernull_Time
    Name                    whereHelperstring
    NonBasicServicesAllowed whereHelperbool
    TotalServices           whereHelperint
    MemoryLimit             whereHelperint
    TotalRoutes             whereHelperint
    InstanceMemoryLimit     whereHelperint
    TotalPrivateDomains     whereHelperint
    AppInstanceLimit        whereHelpernull_Int
    AppTaskLimit            whereHelpernull_Int
    TotalServiceKeys        whereHelpernull_Int
    TotalReservedRoutePorts whereHelpernull_Int
}{
    ID:                      whereHelperint{field: "\"quota_definitions\".\"id\""},
    GUID:                    whereHelperstring{field: "\"quota_definitions\".\"guid\""},
    CreatedAt:               whereHelpertime_Time{field: "\"quota_definitions\".\"created_at\""},
    UpdatedAt:               whereHelpernull_Time{field: "\"quota_definitions\".\"updated_at\""},
    Name:                    whereHelperstring{field: "\"quota_definitions\".\"name\""},
    NonBasicServicesAllowed: whereHelperbool{field: "\"quota_definitions\".\"non_basic_services_allowed\""},
    TotalServices:           whereHelperint{field: "\"quota_definitions\".\"total_services\""},
    MemoryLimit:             whereHelperint{field: "\"quota_definitions\".\"memory_limit\""},
    TotalRoutes:             whereHelperint{field: "\"quota_definitions\".\"total_routes\""},
    InstanceMemoryLimit:     whereHelperint{field: "\"quota_definitions\".\"instance_memory_limit\""},
    TotalPrivateDomains:     whereHelperint{field: "\"quota_definitions\".\"total_private_domains\""},
    AppInstanceLimit:        whereHelpernull_Int{field: "\"quota_definitions\".\"app_instance_limit\""},
    AppTaskLimit:            whereHelpernull_Int{field: "\"quota_definitions\".\"app_task_limit\""},
    TotalServiceKeys:        whereHelpernull_Int{field: "\"quota_definitions\".\"total_service_keys\""},
    TotalReservedRoutePorts: whereHelpernull_Int{field: "\"quota_definitions\".\"total_reserved_route_ports\""},
}
var RequestCountColumns = struct {
    ID         string
    UserGUID   string
    Count      string
    ValidUntil string
}{
    ID:         "id",
    UserGUID:   "user_guid",
    Count:      "count",
    ValidUntil: "valid_until",
}

RequestCountRels is where relationship names are stored.

var RequestCountRels = struct {
}{}
var RequestCountTableColumns = struct {
    ID         string
    UserGUID   string
    Count      string
    ValidUntil string
}{
    ID:         "request_counts.id",
    UserGUID:   "request_counts.user_guid",
    Count:      "request_counts.count",
    ValidUntil: "request_counts.valid_until",
}
var RequestCountWhere = struct {
    ID         whereHelperint
    UserGUID   whereHelpernull_String
    Count      whereHelpernull_Int
    ValidUntil whereHelpernull_Time
}{
    ID:         whereHelperint{field: "\"request_counts\".\"id\""},
    UserGUID:   whereHelpernull_String{field: "\"request_counts\".\"user_guid\""},
    Count:      whereHelpernull_Int{field: "\"request_counts\".\"count\""},
    ValidUntil: whereHelpernull_Time{field: "\"request_counts\".\"valid_until\""},
}
var RevisionAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

RevisionAnnotationRels is where relationship names are stored.

var RevisionAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var RevisionAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "revision_annotations.id",
    GUID:         "revision_annotations.guid",
    CreatedAt:    "revision_annotations.created_at",
    UpdatedAt:    "revision_annotations.updated_at",
    ResourceGUID: "revision_annotations.resource_guid",
    KeyPrefix:    "revision_annotations.key_prefix",
    Key:          "revision_annotations.key",
    Value:        "revision_annotations.value",
}
var RevisionAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"revision_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"revision_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"revision_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"revision_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"revision_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"revision_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"revision_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"revision_annotations\".\"value\""},
}
var RevisionColumns = struct {
    ID                            string
    GUID                          string
    CreatedAt                     string
    UpdatedAt                     string
    AppGUID                       string
    Version                       string
    DropletGUID                   string
    EncryptedEnvironmentVariables string
    Salt                          string
    EncryptionKeyLabel            string
    EncryptionIterations          string
    Description                   string
}{
    ID:                            "id",
    GUID:                          "guid",
    CreatedAt:                     "created_at",
    UpdatedAt:                     "updated_at",
    AppGUID:                       "app_guid",
    Version:                       "version",
    DropletGUID:                   "droplet_guid",
    EncryptedEnvironmentVariables: "encrypted_environment_variables",
    Salt:                          "salt",
    EncryptionKeyLabel:            "encryption_key_label",
    EncryptionIterations:          "encryption_iterations",
    Description:                   "description",
}
var RevisionLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

RevisionLabelRels is where relationship names are stored.

var RevisionLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var RevisionLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "revision_labels.id",
    GUID:         "revision_labels.guid",
    CreatedAt:    "revision_labels.created_at",
    UpdatedAt:    "revision_labels.updated_at",
    ResourceGUID: "revision_labels.resource_guid",
    KeyPrefix:    "revision_labels.key_prefix",
    KeyName:      "revision_labels.key_name",
    Value:        "revision_labels.value",
}
var RevisionLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"revision_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"revision_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"revision_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"revision_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"revision_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"revision_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"revision_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"revision_labels\".\"value\""},
}
var RevisionProcessCommandColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    RevisionGUID   string
    ProcessType    string
    ProcessCommand string
}{
    ID:             "id",
    GUID:           "guid",
    CreatedAt:      "created_at",
    UpdatedAt:      "updated_at",
    RevisionGUID:   "revision_guid",
    ProcessType:    "process_type",
    ProcessCommand: "process_command",
}

RevisionProcessCommandRels is where relationship names are stored.

var RevisionProcessCommandRels = struct {
    Revision string
}{
    Revision: "Revision",
}
var RevisionProcessCommandTableColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    RevisionGUID   string
    ProcessType    string
    ProcessCommand string
}{
    ID:             "revision_process_commands.id",
    GUID:           "revision_process_commands.guid",
    CreatedAt:      "revision_process_commands.created_at",
    UpdatedAt:      "revision_process_commands.updated_at",
    RevisionGUID:   "revision_process_commands.revision_guid",
    ProcessType:    "revision_process_commands.process_type",
    ProcessCommand: "revision_process_commands.process_command",
}
var RevisionProcessCommandWhere = struct {
    ID             whereHelperint
    GUID           whereHelperstring
    CreatedAt      whereHelpertime_Time
    UpdatedAt      whereHelpernull_Time
    RevisionGUID   whereHelperstring
    ProcessType    whereHelperstring
    ProcessCommand whereHelpernull_String
}{
    ID:             whereHelperint{field: "\"revision_process_commands\".\"id\""},
    GUID:           whereHelperstring{field: "\"revision_process_commands\".\"guid\""},
    CreatedAt:      whereHelpertime_Time{field: "\"revision_process_commands\".\"created_at\""},
    UpdatedAt:      whereHelpernull_Time{field: "\"revision_process_commands\".\"updated_at\""},
    RevisionGUID:   whereHelperstring{field: "\"revision_process_commands\".\"revision_guid\""},
    ProcessType:    whereHelperstring{field: "\"revision_process_commands\".\"process_type\""},
    ProcessCommand: whereHelpernull_String{field: "\"revision_process_commands\".\"process_command\""},
}

RevisionRels is where relationship names are stored.

var RevisionRels = struct {
    App                         string
    ResourceRevisionAnnotations string
    ResourceRevisionLabels      string
    RevisionProcessCommands     string
    RevisionSidecars            string
}{
    App:                         "App",
    ResourceRevisionAnnotations: "ResourceRevisionAnnotations",
    ResourceRevisionLabels:      "ResourceRevisionLabels",
    RevisionProcessCommands:     "RevisionProcessCommands",
    RevisionSidecars:            "RevisionSidecars",
}
var RevisionSidecarColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    Name         string
    Command      string
    RevisionGUID string
    Memory       string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    Name:         "name",
    Command:      "command",
    RevisionGUID: "revision_guid",
    Memory:       "memory",
}
var RevisionSidecarProcessTypeColumns = struct {
    ID                  string
    GUID                string
    CreatedAt           string
    UpdatedAt           string
    Type                string
    RevisionSidecarGUID string
}{
    ID:                  "id",
    GUID:                "guid",
    CreatedAt:           "created_at",
    UpdatedAt:           "updated_at",
    Type:                "type",
    RevisionSidecarGUID: "revision_sidecar_guid",
}

RevisionSidecarProcessTypeRels is where relationship names are stored.

var RevisionSidecarProcessTypeRels = struct {
    RevisionSidecar string
}{
    RevisionSidecar: "RevisionSidecar",
}
var RevisionSidecarProcessTypeTableColumns = struct {
    ID                  string
    GUID                string
    CreatedAt           string
    UpdatedAt           string
    Type                string
    RevisionSidecarGUID string
}{
    ID:                  "revision_sidecar_process_types.id",
    GUID:                "revision_sidecar_process_types.guid",
    CreatedAt:           "revision_sidecar_process_types.created_at",
    UpdatedAt:           "revision_sidecar_process_types.updated_at",
    Type:                "revision_sidecar_process_types.type",
    RevisionSidecarGUID: "revision_sidecar_process_types.revision_sidecar_guid",
}
var RevisionSidecarProcessTypeWhere = struct {
    ID                  whereHelperint
    GUID                whereHelperstring
    CreatedAt           whereHelpertime_Time
    UpdatedAt           whereHelpernull_Time
    Type                whereHelperstring
    RevisionSidecarGUID whereHelperstring
}{
    ID:                  whereHelperint{field: "\"revision_sidecar_process_types\".\"id\""},
    GUID:                whereHelperstring{field: "\"revision_sidecar_process_types\".\"guid\""},
    CreatedAt:           whereHelpertime_Time{field: "\"revision_sidecar_process_types\".\"created_at\""},
    UpdatedAt:           whereHelpernull_Time{field: "\"revision_sidecar_process_types\".\"updated_at\""},
    Type:                whereHelperstring{field: "\"revision_sidecar_process_types\".\"type\""},
    RevisionSidecarGUID: whereHelperstring{field: "\"revision_sidecar_process_types\".\"revision_sidecar_guid\""},
}

RevisionSidecarRels is where relationship names are stored.

var RevisionSidecarRels = struct {
    Revision                    string
    RevisionSidecarProcessTypes string
}{
    Revision:                    "Revision",
    RevisionSidecarProcessTypes: "RevisionSidecarProcessTypes",
}
var RevisionSidecarTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    Name         string
    Command      string
    RevisionGUID string
    Memory       string
}{
    ID:           "revision_sidecars.id",
    GUID:         "revision_sidecars.guid",
    CreatedAt:    "revision_sidecars.created_at",
    UpdatedAt:    "revision_sidecars.updated_at",
    Name:         "revision_sidecars.name",
    Command:      "revision_sidecars.command",
    RevisionGUID: "revision_sidecars.revision_guid",
    Memory:       "revision_sidecars.memory",
}
var RevisionSidecarWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    Name         whereHelperstring
    Command      whereHelperstring
    RevisionGUID whereHelperstring
    Memory       whereHelpernull_Int
}{
    ID:           whereHelperint{field: "\"revision_sidecars\".\"id\""},
    GUID:         whereHelperstring{field: "\"revision_sidecars\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"revision_sidecars\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"revision_sidecars\".\"updated_at\""},
    Name:         whereHelperstring{field: "\"revision_sidecars\".\"name\""},
    Command:      whereHelperstring{field: "\"revision_sidecars\".\"command\""},
    RevisionGUID: whereHelperstring{field: "\"revision_sidecars\".\"revision_guid\""},
    Memory:       whereHelpernull_Int{field: "\"revision_sidecars\".\"memory\""},
}
var RevisionTableColumns = struct {
    ID                            string
    GUID                          string
    CreatedAt                     string
    UpdatedAt                     string
    AppGUID                       string
    Version                       string
    DropletGUID                   string
    EncryptedEnvironmentVariables string
    Salt                          string
    EncryptionKeyLabel            string
    EncryptionIterations          string
    Description                   string
}{
    ID:                            "revisions.id",
    GUID:                          "revisions.guid",
    CreatedAt:                     "revisions.created_at",
    UpdatedAt:                     "revisions.updated_at",
    AppGUID:                       "revisions.app_guid",
    Version:                       "revisions.version",
    DropletGUID:                   "revisions.droplet_guid",
    EncryptedEnvironmentVariables: "revisions.encrypted_environment_variables",
    Salt:                          "revisions.salt",
    EncryptionKeyLabel:            "revisions.encryption_key_label",
    EncryptionIterations:          "revisions.encryption_iterations",
    Description:                   "revisions.description",
}
var RevisionWhere = struct {
    ID                            whereHelperint
    GUID                          whereHelperstring
    CreatedAt                     whereHelpertime_Time
    UpdatedAt                     whereHelpernull_Time
    AppGUID                       whereHelpernull_String
    Version                       whereHelpernull_Int
    DropletGUID                   whereHelpernull_String
    EncryptedEnvironmentVariables whereHelpernull_String
    Salt                          whereHelpernull_String
    EncryptionKeyLabel            whereHelpernull_String
    EncryptionIterations          whereHelperint
    Description                   whereHelperstring
}{
    ID:                            whereHelperint{field: "\"revisions\".\"id\""},
    GUID:                          whereHelperstring{field: "\"revisions\".\"guid\""},
    CreatedAt:                     whereHelpertime_Time{field: "\"revisions\".\"created_at\""},
    UpdatedAt:                     whereHelpernull_Time{field: "\"revisions\".\"updated_at\""},
    AppGUID:                       whereHelpernull_String{field: "\"revisions\".\"app_guid\""},
    Version:                       whereHelpernull_Int{field: "\"revisions\".\"version\""},
    DropletGUID:                   whereHelpernull_String{field: "\"revisions\".\"droplet_guid\""},
    EncryptedEnvironmentVariables: whereHelpernull_String{field: "\"revisions\".\"encrypted_environment_variables\""},
    Salt:                          whereHelpernull_String{field: "\"revisions\".\"salt\""},
    EncryptionKeyLabel:            whereHelpernull_String{field: "\"revisions\".\"encryption_key_label\""},
    EncryptionIterations:          whereHelperint{field: "\"revisions\".\"encryption_iterations\""},
    Description:                   whereHelperstring{field: "\"revisions\".\"description\""},
}
var RouteAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

RouteAnnotationRels is where relationship names are stored.

var RouteAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var RouteAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "route_annotations.id",
    GUID:         "route_annotations.guid",
    CreatedAt:    "route_annotations.created_at",
    UpdatedAt:    "route_annotations.updated_at",
    ResourceGUID: "route_annotations.resource_guid",
    KeyPrefix:    "route_annotations.key_prefix",
    Key:          "route_annotations.key",
    Value:        "route_annotations.value",
}
var RouteAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"route_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"route_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"route_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"route_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"route_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"route_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"route_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"route_annotations\".\"value\""},
}
var RouteBindingAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

RouteBindingAnnotationRels is where relationship names are stored.

var RouteBindingAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var RouteBindingAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "route_binding_annotations.id",
    GUID:         "route_binding_annotations.guid",
    CreatedAt:    "route_binding_annotations.created_at",
    UpdatedAt:    "route_binding_annotations.updated_at",
    ResourceGUID: "route_binding_annotations.resource_guid",
    KeyPrefix:    "route_binding_annotations.key_prefix",
    Key:          "route_binding_annotations.key",
    Value:        "route_binding_annotations.value",
}
var RouteBindingAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"route_binding_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"route_binding_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"route_binding_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"route_binding_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"route_binding_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"route_binding_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"route_binding_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"route_binding_annotations\".\"value\""},
}
var RouteBindingColumns = struct {
    ID                string
    GUID              string
    CreatedAt         string
    UpdatedAt         string
    RouteID           string
    ServiceInstanceID string
    RouteServiceURL   string
}{
    ID:                "id",
    GUID:              "guid",
    CreatedAt:         "created_at",
    UpdatedAt:         "updated_at",
    RouteID:           "route_id",
    ServiceInstanceID: "service_instance_id",
    RouteServiceURL:   "route_service_url",
}
var RouteBindingLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

RouteBindingLabelRels is where relationship names are stored.

var RouteBindingLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var RouteBindingLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "route_binding_labels.id",
    GUID:         "route_binding_labels.guid",
    CreatedAt:    "route_binding_labels.created_at",
    UpdatedAt:    "route_binding_labels.updated_at",
    ResourceGUID: "route_binding_labels.resource_guid",
    KeyPrefix:    "route_binding_labels.key_prefix",
    KeyName:      "route_binding_labels.key_name",
    Value:        "route_binding_labels.value",
}
var RouteBindingLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"route_binding_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"route_binding_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"route_binding_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"route_binding_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"route_binding_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"route_binding_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"route_binding_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"route_binding_labels\".\"value\""},
}
var RouteBindingOperationColumns = struct {
    ID                      string
    CreatedAt               string
    UpdatedAt               string
    RouteBindingID          string
    State                   string
    Type                    string
    Description             string
    BrokerProvidedOperation string
}{
    ID:                      "id",
    CreatedAt:               "created_at",
    UpdatedAt:               "updated_at",
    RouteBindingID:          "route_binding_id",
    State:                   "state",
    Type:                    "type",
    Description:             "description",
    BrokerProvidedOperation: "broker_provided_operation",
}

RouteBindingOperationRels is where relationship names are stored.

var RouteBindingOperationRels = struct {
    RouteBinding string
}{
    RouteBinding: "RouteBinding",
}
var RouteBindingOperationTableColumns = struct {
    ID                      string
    CreatedAt               string
    UpdatedAt               string
    RouteBindingID          string
    State                   string
    Type                    string
    Description             string
    BrokerProvidedOperation string
}{
    ID:                      "route_binding_operations.id",
    CreatedAt:               "route_binding_operations.created_at",
    UpdatedAt:               "route_binding_operations.updated_at",
    RouteBindingID:          "route_binding_operations.route_binding_id",
    State:                   "route_binding_operations.state",
    Type:                    "route_binding_operations.type",
    Description:             "route_binding_operations.description",
    BrokerProvidedOperation: "route_binding_operations.broker_provided_operation",
}
var RouteBindingOperationWhere = struct {
    ID                      whereHelperint
    CreatedAt               whereHelpertime_Time
    UpdatedAt               whereHelpernull_Time
    RouteBindingID          whereHelpernull_Int
    State                   whereHelperstring
    Type                    whereHelperstring
    Description             whereHelpernull_String
    BrokerProvidedOperation whereHelpernull_String
}{
    ID:                      whereHelperint{field: "\"route_binding_operations\".\"id\""},
    CreatedAt:               whereHelpertime_Time{field: "\"route_binding_operations\".\"created_at\""},
    UpdatedAt:               whereHelpernull_Time{field: "\"route_binding_operations\".\"updated_at\""},
    RouteBindingID:          whereHelpernull_Int{field: "\"route_binding_operations\".\"route_binding_id\""},
    State:                   whereHelperstring{field: "\"route_binding_operations\".\"state\""},
    Type:                    whereHelperstring{field: "\"route_binding_operations\".\"type\""},
    Description:             whereHelpernull_String{field: "\"route_binding_operations\".\"description\""},
    BrokerProvidedOperation: whereHelpernull_String{field: "\"route_binding_operations\".\"broker_provided_operation\""},
}

RouteBindingRels is where relationship names are stored.

var RouteBindingRels = struct {
    Route                           string
    ServiceInstance                 string
    RouteBindingOperation           string
    ResourceRouteBindingAnnotations string
    ResourceRouteBindingLabels      string
}{
    Route:                           "Route",
    ServiceInstance:                 "ServiceInstance",
    RouteBindingOperation:           "RouteBindingOperation",
    ResourceRouteBindingAnnotations: "ResourceRouteBindingAnnotations",
    ResourceRouteBindingLabels:      "ResourceRouteBindingLabels",
}
var RouteBindingTableColumns = struct {
    ID                string
    GUID              string
    CreatedAt         string
    UpdatedAt         string
    RouteID           string
    ServiceInstanceID string
    RouteServiceURL   string
}{
    ID:                "route_bindings.id",
    GUID:              "route_bindings.guid",
    CreatedAt:         "route_bindings.created_at",
    UpdatedAt:         "route_bindings.updated_at",
    RouteID:           "route_bindings.route_id",
    ServiceInstanceID: "route_bindings.service_instance_id",
    RouteServiceURL:   "route_bindings.route_service_url",
}
var RouteBindingWhere = struct {
    ID                whereHelperint
    GUID              whereHelperstring
    CreatedAt         whereHelpertime_Time
    UpdatedAt         whereHelpernull_Time
    RouteID           whereHelpernull_Int
    ServiceInstanceID whereHelpernull_Int
    RouteServiceURL   whereHelpernull_String
}{
    ID:                whereHelperint{field: "\"route_bindings\".\"id\""},
    GUID:              whereHelperstring{field: "\"route_bindings\".\"guid\""},
    CreatedAt:         whereHelpertime_Time{field: "\"route_bindings\".\"created_at\""},
    UpdatedAt:         whereHelpernull_Time{field: "\"route_bindings\".\"updated_at\""},
    RouteID:           whereHelpernull_Int{field: "\"route_bindings\".\"route_id\""},
    ServiceInstanceID: whereHelpernull_Int{field: "\"route_bindings\".\"service_instance_id\""},
    RouteServiceURL:   whereHelpernull_String{field: "\"route_bindings\".\"route_service_url\""},
}
var RouteColumns = struct {
    ID        string
    GUID      string
    CreatedAt string
    UpdatedAt string
    Host      string
    DomainID  string
    SpaceID   string
    Path      string
    Port      string
    VipOffset string
}{
    ID:        "id",
    GUID:      "guid",
    CreatedAt: "created_at",
    UpdatedAt: "updated_at",
    Host:      "host",
    DomainID:  "domain_id",
    SpaceID:   "space_id",
    Path:      "path",
    Port:      "port",
    VipOffset: "vip_offset",
}
var RouteLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

RouteLabelRels is where relationship names are stored.

var RouteLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var RouteLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "route_labels.id",
    GUID:         "route_labels.guid",
    CreatedAt:    "route_labels.created_at",
    UpdatedAt:    "route_labels.updated_at",
    ResourceGUID: "route_labels.resource_guid",
    KeyPrefix:    "route_labels.key_prefix",
    KeyName:      "route_labels.key_name",
    Value:        "route_labels.value",
}
var RouteLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"route_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"route_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"route_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"route_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"route_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"route_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"route_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"route_labels\".\"value\""},
}
var RouteMappingColumns = struct {
    ID          string
    CreatedAt   string
    UpdatedAt   string
    AppPort     string
    GUID        string
    AppGUID     string
    RouteGUID   string
    ProcessType string
    Weight      string
}{
    ID:          "id",
    CreatedAt:   "created_at",
    UpdatedAt:   "updated_at",
    AppPort:     "app_port",
    GUID:        "guid",
    AppGUID:     "app_guid",
    RouteGUID:   "route_guid",
    ProcessType: "process_type",
    Weight:      "weight",
}

RouteMappingRels is where relationship names are stored.

var RouteMappingRels = struct {
    App   string
    Route string
}{
    App:   "App",
    Route: "Route",
}
var RouteMappingTableColumns = struct {
    ID          string
    CreatedAt   string
    UpdatedAt   string
    AppPort     string
    GUID        string
    AppGUID     string
    RouteGUID   string
    ProcessType string
    Weight      string
}{
    ID:          "route_mappings.id",
    CreatedAt:   "route_mappings.created_at",
    UpdatedAt:   "route_mappings.updated_at",
    AppPort:     "route_mappings.app_port",
    GUID:        "route_mappings.guid",
    AppGUID:     "route_mappings.app_guid",
    RouteGUID:   "route_mappings.route_guid",
    ProcessType: "route_mappings.process_type",
    Weight:      "route_mappings.weight",
}
var RouteMappingWhere = struct {
    ID          whereHelperint
    CreatedAt   whereHelpertime_Time
    UpdatedAt   whereHelpernull_Time
    AppPort     whereHelpernull_Int
    GUID        whereHelperstring
    AppGUID     whereHelperstring
    RouteGUID   whereHelperstring
    ProcessType whereHelpernull_String
    Weight      whereHelpernull_Int
}{
    ID:          whereHelperint{field: "\"route_mappings\".\"id\""},
    CreatedAt:   whereHelpertime_Time{field: "\"route_mappings\".\"created_at\""},
    UpdatedAt:   whereHelpernull_Time{field: "\"route_mappings\".\"updated_at\""},
    AppPort:     whereHelpernull_Int{field: "\"route_mappings\".\"app_port\""},
    GUID:        whereHelperstring{field: "\"route_mappings\".\"guid\""},
    AppGUID:     whereHelperstring{field: "\"route_mappings\".\"app_guid\""},
    RouteGUID:   whereHelperstring{field: "\"route_mappings\".\"route_guid\""},
    ProcessType: whereHelpernull_String{field: "\"route_mappings\".\"process_type\""},
    Weight:      whereHelpernull_Int{field: "\"route_mappings\".\"weight\""},
}

RouteRels is where relationship names are stored.

var RouteRels = struct {
    Domain                   string
    Space                    string
    ResourceRouteAnnotations string
    RouteBindings            string
    ResourceRouteLabels      string
    RouteMappings            string
}{
    Domain:                   "Domain",
    Space:                    "Space",
    ResourceRouteAnnotations: "ResourceRouteAnnotations",
    RouteBindings:            "RouteBindings",
    ResourceRouteLabels:      "ResourceRouteLabels",
    RouteMappings:            "RouteMappings",
}
var RouteTableColumns = struct {
    ID        string
    GUID      string
    CreatedAt string
    UpdatedAt string
    Host      string
    DomainID  string
    SpaceID   string
    Path      string
    Port      string
    VipOffset string
}{
    ID:        "routes.id",
    GUID:      "routes.guid",
    CreatedAt: "routes.created_at",
    UpdatedAt: "routes.updated_at",
    Host:      "routes.host",
    DomainID:  "routes.domain_id",
    SpaceID:   "routes.space_id",
    Path:      "routes.path",
    Port:      "routes.port",
    VipOffset: "routes.vip_offset",
}
var RouteWhere = struct {
    ID        whereHelperint
    GUID      whereHelperstring
    CreatedAt whereHelpertime_Time
    UpdatedAt whereHelpernull_Time
    Host      whereHelperstring
    DomainID  whereHelperint
    SpaceID   whereHelperint
    Path      whereHelperstring
    Port      whereHelperint
    VipOffset whereHelpernull_Int
}{
    ID:        whereHelperint{field: "\"routes\".\"id\""},
    GUID:      whereHelperstring{field: "\"routes\".\"guid\""},
    CreatedAt: whereHelpertime_Time{field: "\"routes\".\"created_at\""},
    UpdatedAt: whereHelpernull_Time{field: "\"routes\".\"updated_at\""},
    Host:      whereHelperstring{field: "\"routes\".\"host\""},
    DomainID:  whereHelperint{field: "\"routes\".\"domain_id\""},
    SpaceID:   whereHelperint{field: "\"routes\".\"space_id\""},
    Path:      whereHelperstring{field: "\"routes\".\"path\""},
    Port:      whereHelperint{field: "\"routes\".\"port\""},
    VipOffset: whereHelpernull_Int{field: "\"routes\".\"vip_offset\""},
}
var SchemaMigrationColumns = struct {
    Filename string
}{
    Filename: "filename",
}

SchemaMigrationRels is where relationship names are stored.

var SchemaMigrationRels = struct {
}{}
var SchemaMigrationTableColumns = struct {
    Filename string
}{
    Filename: "schema_migrations.filename",
}
var SchemaMigrationWhere = struct {
    Filename whereHelperstring
}{
    Filename: whereHelperstring{field: "\"schema_migrations\".\"filename\""},
}
var SecurityGroupColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    Name           string
    Rules          string
    StagingDefault string
    RunningDefault string
}{
    ID:             "id",
    GUID:           "guid",
    CreatedAt:      "created_at",
    UpdatedAt:      "updated_at",
    Name:           "name",
    Rules:          "rules",
    StagingDefault: "staging_default",
    RunningDefault: "running_default",
}

SecurityGroupRels is where relationship names are stored.

var SecurityGroupRels = struct {
    SecurityGroupsSpaces                            string
    StagingSecurityGroupStagingSecurityGroupsSpaces string
}{
    SecurityGroupsSpaces:                            "SecurityGroupsSpaces",
    StagingSecurityGroupStagingSecurityGroupsSpaces: "StagingSecurityGroupStagingSecurityGroupsSpaces",
}
var SecurityGroupTableColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    Name           string
    Rules          string
    StagingDefault string
    RunningDefault string
}{
    ID:             "security_groups.id",
    GUID:           "security_groups.guid",
    CreatedAt:      "security_groups.created_at",
    UpdatedAt:      "security_groups.updated_at",
    Name:           "security_groups.name",
    Rules:          "security_groups.rules",
    StagingDefault: "security_groups.staging_default",
    RunningDefault: "security_groups.running_default",
}
var SecurityGroupWhere = struct {
    ID             whereHelperint
    GUID           whereHelperstring
    CreatedAt      whereHelpertime_Time
    UpdatedAt      whereHelpernull_Time
    Name           whereHelperstring
    Rules          whereHelpernull_String
    StagingDefault whereHelpernull_Bool
    RunningDefault whereHelpernull_Bool
}{
    ID:             whereHelperint{field: "\"security_groups\".\"id\""},
    GUID:           whereHelperstring{field: "\"security_groups\".\"guid\""},
    CreatedAt:      whereHelpertime_Time{field: "\"security_groups\".\"created_at\""},
    UpdatedAt:      whereHelpernull_Time{field: "\"security_groups\".\"updated_at\""},
    Name:           whereHelperstring{field: "\"security_groups\".\"name\""},
    Rules:          whereHelpernull_String{field: "\"security_groups\".\"rules\""},
    StagingDefault: whereHelpernull_Bool{field: "\"security_groups\".\"staging_default\""},
    RunningDefault: whereHelpernull_Bool{field: "\"security_groups\".\"running_default\""},
}
var SecurityGroupsSpaceColumns = struct {
    SecurityGroupID        string
    SpaceID                string
    SecurityGroupsSpacesPK string
}{
    SecurityGroupID:        "security_group_id",
    SpaceID:                "space_id",
    SecurityGroupsSpacesPK: "security_groups_spaces_pk",
}

SecurityGroupsSpaceRels is where relationship names are stored.

var SecurityGroupsSpaceRels = struct {
    SecurityGroup string
    Space         string
}{
    SecurityGroup: "SecurityGroup",
    Space:         "Space",
}
var SecurityGroupsSpaceTableColumns = struct {
    SecurityGroupID        string
    SpaceID                string
    SecurityGroupsSpacesPK string
}{
    SecurityGroupID:        "security_groups_spaces.security_group_id",
    SpaceID:                "security_groups_spaces.space_id",
    SecurityGroupsSpacesPK: "security_groups_spaces.security_groups_spaces_pk",
}
var SecurityGroupsSpaceWhere = struct {
    SecurityGroupID        whereHelperint
    SpaceID                whereHelperint
    SecurityGroupsSpacesPK whereHelperint
}{
    SecurityGroupID:        whereHelperint{field: "\"security_groups_spaces\".\"security_group_id\""},
    SpaceID:                whereHelperint{field: "\"security_groups_spaces\".\"space_id\""},
    SecurityGroupsSpacesPK: whereHelperint{field: "\"security_groups_spaces\".\"security_groups_spaces_pk\""},
}
var ServiceBindingAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

ServiceBindingAnnotationRels is where relationship names are stored.

var ServiceBindingAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceBindingAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "service_binding_annotations.id",
    GUID:         "service_binding_annotations.guid",
    CreatedAt:    "service_binding_annotations.created_at",
    UpdatedAt:    "service_binding_annotations.updated_at",
    ResourceGUID: "service_binding_annotations.resource_guid",
    KeyPrefix:    "service_binding_annotations.key_prefix",
    Key:          "service_binding_annotations.key",
    Value:        "service_binding_annotations.value",
}
var ServiceBindingAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_binding_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_binding_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_binding_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_binding_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_binding_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_binding_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"service_binding_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"service_binding_annotations\".\"value\""},
}
var ServiceBindingColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Credentials          string
    Salt                 string
    SyslogDrainURL       string
    VolumeMounts         string
    VolumeMountsSalt     string
    AppGUID              string
    ServiceInstanceGUID  string
    Type                 string
    Name                 string
    EncryptionKeyLabel   string
    EncryptionIterations string
}{
    ID:                   "id",
    GUID:                 "guid",
    CreatedAt:            "created_at",
    UpdatedAt:            "updated_at",
    Credentials:          "credentials",
    Salt:                 "salt",
    SyslogDrainURL:       "syslog_drain_url",
    VolumeMounts:         "volume_mounts",
    VolumeMountsSalt:     "volume_mounts_salt",
    AppGUID:              "app_guid",
    ServiceInstanceGUID:  "service_instance_guid",
    Type:                 "type",
    Name:                 "name",
    EncryptionKeyLabel:   "encryption_key_label",
    EncryptionIterations: "encryption_iterations",
}
var ServiceBindingLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

ServiceBindingLabelRels is where relationship names are stored.

var ServiceBindingLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceBindingLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "service_binding_labels.id",
    GUID:         "service_binding_labels.guid",
    CreatedAt:    "service_binding_labels.created_at",
    UpdatedAt:    "service_binding_labels.updated_at",
    ResourceGUID: "service_binding_labels.resource_guid",
    KeyPrefix:    "service_binding_labels.key_prefix",
    KeyName:      "service_binding_labels.key_name",
    Value:        "service_binding_labels.value",
}
var ServiceBindingLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_binding_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_binding_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_binding_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_binding_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_binding_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_binding_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"service_binding_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"service_binding_labels\".\"value\""},
}
var ServiceBindingOperationColumns = struct {
    ID                      string
    CreatedAt               string
    UpdatedAt               string
    ServiceBindingID        string
    State                   string
    Type                    string
    Description             string
    BrokerProvidedOperation string
}{
    ID:                      "id",
    CreatedAt:               "created_at",
    UpdatedAt:               "updated_at",
    ServiceBindingID:        "service_binding_id",
    State:                   "state",
    Type:                    "type",
    Description:             "description",
    BrokerProvidedOperation: "broker_provided_operation",
}

ServiceBindingOperationRels is where relationship names are stored.

var ServiceBindingOperationRels = struct {
    ServiceBinding string
}{
    ServiceBinding: "ServiceBinding",
}
var ServiceBindingOperationTableColumns = struct {
    ID                      string
    CreatedAt               string
    UpdatedAt               string
    ServiceBindingID        string
    State                   string
    Type                    string
    Description             string
    BrokerProvidedOperation string
}{
    ID:                      "service_binding_operations.id",
    CreatedAt:               "service_binding_operations.created_at",
    UpdatedAt:               "service_binding_operations.updated_at",
    ServiceBindingID:        "service_binding_operations.service_binding_id",
    State:                   "service_binding_operations.state",
    Type:                    "service_binding_operations.type",
    Description:             "service_binding_operations.description",
    BrokerProvidedOperation: "service_binding_operations.broker_provided_operation",
}
var ServiceBindingOperationWhere = struct {
    ID                      whereHelperint
    CreatedAt               whereHelpertime_Time
    UpdatedAt               whereHelpernull_Time
    ServiceBindingID        whereHelpernull_Int
    State                   whereHelperstring
    Type                    whereHelperstring
    Description             whereHelpernull_String
    BrokerProvidedOperation whereHelpernull_String
}{
    ID:                      whereHelperint{field: "\"service_binding_operations\".\"id\""},
    CreatedAt:               whereHelpertime_Time{field: "\"service_binding_operations\".\"created_at\""},
    UpdatedAt:               whereHelpernull_Time{field: "\"service_binding_operations\".\"updated_at\""},
    ServiceBindingID:        whereHelpernull_Int{field: "\"service_binding_operations\".\"service_binding_id\""},
    State:                   whereHelperstring{field: "\"service_binding_operations\".\"state\""},
    Type:                    whereHelperstring{field: "\"service_binding_operations\".\"type\""},
    Description:             whereHelpernull_String{field: "\"service_binding_operations\".\"description\""},
    BrokerProvidedOperation: whereHelpernull_String{field: "\"service_binding_operations\".\"broker_provided_operation\""},
}

ServiceBindingRels is where relationship names are stored.

var ServiceBindingRels = struct {
    App                               string
    ServiceInstance                   string
    ServiceBindingOperation           string
    ResourceServiceBindingAnnotations string
    ResourceServiceBindingLabels      string
}{
    App:                               "App",
    ServiceInstance:                   "ServiceInstance",
    ServiceBindingOperation:           "ServiceBindingOperation",
    ResourceServiceBindingAnnotations: "ResourceServiceBindingAnnotations",
    ResourceServiceBindingLabels:      "ResourceServiceBindingLabels",
}
var ServiceBindingTableColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Credentials          string
    Salt                 string
    SyslogDrainURL       string
    VolumeMounts         string
    VolumeMountsSalt     string
    AppGUID              string
    ServiceInstanceGUID  string
    Type                 string
    Name                 string
    EncryptionKeyLabel   string
    EncryptionIterations string
}{
    ID:                   "service_bindings.id",
    GUID:                 "service_bindings.guid",
    CreatedAt:            "service_bindings.created_at",
    UpdatedAt:            "service_bindings.updated_at",
    Credentials:          "service_bindings.credentials",
    Salt:                 "service_bindings.salt",
    SyslogDrainURL:       "service_bindings.syslog_drain_url",
    VolumeMounts:         "service_bindings.volume_mounts",
    VolumeMountsSalt:     "service_bindings.volume_mounts_salt",
    AppGUID:              "service_bindings.app_guid",
    ServiceInstanceGUID:  "service_bindings.service_instance_guid",
    Type:                 "service_bindings.type",
    Name:                 "service_bindings.name",
    EncryptionKeyLabel:   "service_bindings.encryption_key_label",
    EncryptionIterations: "service_bindings.encryption_iterations",
}
var ServiceBindingWhere = struct {
    ID                   whereHelperint
    GUID                 whereHelperstring
    CreatedAt            whereHelpertime_Time
    UpdatedAt            whereHelpernull_Time
    Credentials          whereHelperstring
    Salt                 whereHelpernull_String
    SyslogDrainURL       whereHelpernull_String
    VolumeMounts         whereHelpernull_String
    VolumeMountsSalt     whereHelpernull_String
    AppGUID              whereHelperstring
    ServiceInstanceGUID  whereHelperstring
    Type                 whereHelpernull_String
    Name                 whereHelpernull_String
    EncryptionKeyLabel   whereHelpernull_String
    EncryptionIterations whereHelperint
}{
    ID:                   whereHelperint{field: "\"service_bindings\".\"id\""},
    GUID:                 whereHelperstring{field: "\"service_bindings\".\"guid\""},
    CreatedAt:            whereHelpertime_Time{field: "\"service_bindings\".\"created_at\""},
    UpdatedAt:            whereHelpernull_Time{field: "\"service_bindings\".\"updated_at\""},
    Credentials:          whereHelperstring{field: "\"service_bindings\".\"credentials\""},
    Salt:                 whereHelpernull_String{field: "\"service_bindings\".\"salt\""},
    SyslogDrainURL:       whereHelpernull_String{field: "\"service_bindings\".\"syslog_drain_url\""},
    VolumeMounts:         whereHelpernull_String{field: "\"service_bindings\".\"volume_mounts\""},
    VolumeMountsSalt:     whereHelpernull_String{field: "\"service_bindings\".\"volume_mounts_salt\""},
    AppGUID:              whereHelperstring{field: "\"service_bindings\".\"app_guid\""},
    ServiceInstanceGUID:  whereHelperstring{field: "\"service_bindings\".\"service_instance_guid\""},
    Type:                 whereHelpernull_String{field: "\"service_bindings\".\"type\""},
    Name:                 whereHelpernull_String{field: "\"service_bindings\".\"name\""},
    EncryptionKeyLabel:   whereHelpernull_String{field: "\"service_bindings\".\"encryption_key_label\""},
    EncryptionIterations: whereHelperint{field: "\"service_bindings\".\"encryption_iterations\""},
}
var ServiceBrokerAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

ServiceBrokerAnnotationRels is where relationship names are stored.

var ServiceBrokerAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceBrokerAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "service_broker_annotations.id",
    GUID:         "service_broker_annotations.guid",
    CreatedAt:    "service_broker_annotations.created_at",
    UpdatedAt:    "service_broker_annotations.updated_at",
    ResourceGUID: "service_broker_annotations.resource_guid",
    KeyPrefix:    "service_broker_annotations.key_prefix",
    Key:          "service_broker_annotations.key",
    Value:        "service_broker_annotations.value",
}
var ServiceBrokerAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_broker_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_broker_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_broker_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_broker_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_broker_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_broker_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"service_broker_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"service_broker_annotations\".\"value\""},
}
var ServiceBrokerColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    BrokerURL            string
    AuthPassword         string
    Salt                 string
    AuthUsername         string
    SpaceID              string
    EncryptionKeyLabel   string
    EncryptionIterations string
    State                string
}{
    ID:                   "id",
    GUID:                 "guid",
    CreatedAt:            "created_at",
    UpdatedAt:            "updated_at",
    Name:                 "name",
    BrokerURL:            "broker_url",
    AuthPassword:         "auth_password",
    Salt:                 "salt",
    AuthUsername:         "auth_username",
    SpaceID:              "space_id",
    EncryptionKeyLabel:   "encryption_key_label",
    EncryptionIterations: "encryption_iterations",
    State:                "state",
}
var ServiceBrokerLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

ServiceBrokerLabelRels is where relationship names are stored.

var ServiceBrokerLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceBrokerLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "service_broker_labels.id",
    GUID:         "service_broker_labels.guid",
    CreatedAt:    "service_broker_labels.created_at",
    UpdatedAt:    "service_broker_labels.updated_at",
    ResourceGUID: "service_broker_labels.resource_guid",
    KeyPrefix:    "service_broker_labels.key_prefix",
    KeyName:      "service_broker_labels.key_name",
    Value:        "service_broker_labels.value",
}
var ServiceBrokerLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_broker_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_broker_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_broker_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_broker_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_broker_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_broker_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"service_broker_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"service_broker_labels\".\"value\""},
}

ServiceBrokerRels is where relationship names are stored.

var ServiceBrokerRels = struct {
    Space                                      string
    ResourceServiceBrokerAnnotations           string
    ResourceServiceBrokerLabels                string
    FKServiceBrokerServiceBrokerUpdateRequests string
    Services                                   string
}{
    Space:                            "Space",
    ResourceServiceBrokerAnnotations: "ResourceServiceBrokerAnnotations",
    ResourceServiceBrokerLabels:      "ResourceServiceBrokerLabels",
    FKServiceBrokerServiceBrokerUpdateRequests: "FKServiceBrokerServiceBrokerUpdateRequests",
    Services: "Services",
}
var ServiceBrokerTableColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    BrokerURL            string
    AuthPassword         string
    Salt                 string
    AuthUsername         string
    SpaceID              string
    EncryptionKeyLabel   string
    EncryptionIterations string
    State                string
}{
    ID:                   "service_brokers.id",
    GUID:                 "service_brokers.guid",
    CreatedAt:            "service_brokers.created_at",
    UpdatedAt:            "service_brokers.updated_at",
    Name:                 "service_brokers.name",
    BrokerURL:            "service_brokers.broker_url",
    AuthPassword:         "service_brokers.auth_password",
    Salt:                 "service_brokers.salt",
    AuthUsername:         "service_brokers.auth_username",
    SpaceID:              "service_brokers.space_id",
    EncryptionKeyLabel:   "service_brokers.encryption_key_label",
    EncryptionIterations: "service_brokers.encryption_iterations",
    State:                "service_brokers.state",
}
var ServiceBrokerUpdateRequestAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

ServiceBrokerUpdateRequestAnnotationRels is where relationship names are stored.

var ServiceBrokerUpdateRequestAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceBrokerUpdateRequestAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "service_broker_update_request_annotations.id",
    GUID:         "service_broker_update_request_annotations.guid",
    CreatedAt:    "service_broker_update_request_annotations.created_at",
    UpdatedAt:    "service_broker_update_request_annotations.updated_at",
    ResourceGUID: "service_broker_update_request_annotations.resource_guid",
    KeyPrefix:    "service_broker_update_request_annotations.key_prefix",
    Key:          "service_broker_update_request_annotations.key",
    Value:        "service_broker_update_request_annotations.value",
}
var ServiceBrokerUpdateRequestAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_broker_update_request_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_broker_update_request_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_broker_update_request_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_broker_update_request_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_broker_update_request_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_broker_update_request_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"service_broker_update_request_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"service_broker_update_request_annotations\".\"value\""},
}
var ServiceBrokerUpdateRequestColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    BrokerURL            string
    Authentication       string
    Salt                 string
    EncryptionKeyLabel   string
    EncryptionIterations string
    ServiceBrokerID      string
    FKServiceBrokersID   string
}{
    ID:                   "id",
    GUID:                 "guid",
    CreatedAt:            "created_at",
    UpdatedAt:            "updated_at",
    Name:                 "name",
    BrokerURL:            "broker_url",
    Authentication:       "authentication",
    Salt:                 "salt",
    EncryptionKeyLabel:   "encryption_key_label",
    EncryptionIterations: "encryption_iterations",
    ServiceBrokerID:      "service_broker_id",
    FKServiceBrokersID:   "fk_service_brokers_id",
}
var ServiceBrokerUpdateRequestLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

ServiceBrokerUpdateRequestLabelRels is where relationship names are stored.

var ServiceBrokerUpdateRequestLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceBrokerUpdateRequestLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "service_broker_update_request_labels.id",
    GUID:         "service_broker_update_request_labels.guid",
    CreatedAt:    "service_broker_update_request_labels.created_at",
    UpdatedAt:    "service_broker_update_request_labels.updated_at",
    ResourceGUID: "service_broker_update_request_labels.resource_guid",
    KeyPrefix:    "service_broker_update_request_labels.key_prefix",
    KeyName:      "service_broker_update_request_labels.key_name",
    Value:        "service_broker_update_request_labels.value",
}
var ServiceBrokerUpdateRequestLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_broker_update_request_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_broker_update_request_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_broker_update_request_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_broker_update_request_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_broker_update_request_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_broker_update_request_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"service_broker_update_request_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"service_broker_update_request_labels\".\"value\""},
}

ServiceBrokerUpdateRequestRels is where relationship names are stored.

var ServiceBrokerUpdateRequestRels = struct {
    FKServiceBroker                               string
    ResourceServiceBrokerUpdateRequestAnnotations string
    ResourceServiceBrokerUpdateRequestLabels      string
}{
    FKServiceBroker: "FKServiceBroker",
    ResourceServiceBrokerUpdateRequestAnnotations: "ResourceServiceBrokerUpdateRequestAnnotations",
    ResourceServiceBrokerUpdateRequestLabels:      "ResourceServiceBrokerUpdateRequestLabels",
}
var ServiceBrokerUpdateRequestTableColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    BrokerURL            string
    Authentication       string
    Salt                 string
    EncryptionKeyLabel   string
    EncryptionIterations string
    ServiceBrokerID      string
    FKServiceBrokersID   string
}{
    ID:                   "service_broker_update_requests.id",
    GUID:                 "service_broker_update_requests.guid",
    CreatedAt:            "service_broker_update_requests.created_at",
    UpdatedAt:            "service_broker_update_requests.updated_at",
    Name:                 "service_broker_update_requests.name",
    BrokerURL:            "service_broker_update_requests.broker_url",
    Authentication:       "service_broker_update_requests.authentication",
    Salt:                 "service_broker_update_requests.salt",
    EncryptionKeyLabel:   "service_broker_update_requests.encryption_key_label",
    EncryptionIterations: "service_broker_update_requests.encryption_iterations",
    ServiceBrokerID:      "service_broker_update_requests.service_broker_id",
    FKServiceBrokersID:   "service_broker_update_requests.fk_service_brokers_id",
}
var ServiceBrokerUpdateRequestWhere = struct {
    ID                   whereHelperint
    GUID                 whereHelperstring
    CreatedAt            whereHelpertime_Time
    UpdatedAt            whereHelpernull_Time
    Name                 whereHelpernull_String
    BrokerURL            whereHelpernull_String
    Authentication       whereHelpernull_String
    Salt                 whereHelpernull_String
    EncryptionKeyLabel   whereHelpernull_String
    EncryptionIterations whereHelperint
    ServiceBrokerID      whereHelperint
    FKServiceBrokersID   whereHelpernull_Int
}{
    ID:                   whereHelperint{field: "\"service_broker_update_requests\".\"id\""},
    GUID:                 whereHelperstring{field: "\"service_broker_update_requests\".\"guid\""},
    CreatedAt:            whereHelpertime_Time{field: "\"service_broker_update_requests\".\"created_at\""},
    UpdatedAt:            whereHelpernull_Time{field: "\"service_broker_update_requests\".\"updated_at\""},
    Name:                 whereHelpernull_String{field: "\"service_broker_update_requests\".\"name\""},
    BrokerURL:            whereHelpernull_String{field: "\"service_broker_update_requests\".\"broker_url\""},
    Authentication:       whereHelpernull_String{field: "\"service_broker_update_requests\".\"authentication\""},
    Salt:                 whereHelpernull_String{field: "\"service_broker_update_requests\".\"salt\""},
    EncryptionKeyLabel:   whereHelpernull_String{field: "\"service_broker_update_requests\".\"encryption_key_label\""},
    EncryptionIterations: whereHelperint{field: "\"service_broker_update_requests\".\"encryption_iterations\""},
    ServiceBrokerID:      whereHelperint{field: "\"service_broker_update_requests\".\"service_broker_id\""},
    FKServiceBrokersID:   whereHelpernull_Int{field: "\"service_broker_update_requests\".\"fk_service_brokers_id\""},
}
var ServiceBrokerWhere = struct {
    ID                   whereHelperint
    GUID                 whereHelperstring
    CreatedAt            whereHelpertime_Time
    UpdatedAt            whereHelpernull_Time
    Name                 whereHelperstring
    BrokerURL            whereHelperstring
    AuthPassword         whereHelperstring
    Salt                 whereHelpernull_String
    AuthUsername         whereHelpernull_String
    SpaceID              whereHelpernull_Int
    EncryptionKeyLabel   whereHelpernull_String
    EncryptionIterations whereHelperint
    State                whereHelperstring
}{
    ID:                   whereHelperint{field: "\"service_brokers\".\"id\""},
    GUID:                 whereHelperstring{field: "\"service_brokers\".\"guid\""},
    CreatedAt:            whereHelpertime_Time{field: "\"service_brokers\".\"created_at\""},
    UpdatedAt:            whereHelpernull_Time{field: "\"service_brokers\".\"updated_at\""},
    Name:                 whereHelperstring{field: "\"service_brokers\".\"name\""},
    BrokerURL:            whereHelperstring{field: "\"service_brokers\".\"broker_url\""},
    AuthPassword:         whereHelperstring{field: "\"service_brokers\".\"auth_password\""},
    Salt:                 whereHelpernull_String{field: "\"service_brokers\".\"salt\""},
    AuthUsername:         whereHelpernull_String{field: "\"service_brokers\".\"auth_username\""},
    SpaceID:              whereHelpernull_Int{field: "\"service_brokers\".\"space_id\""},
    EncryptionKeyLabel:   whereHelpernull_String{field: "\"service_brokers\".\"encryption_key_label\""},
    EncryptionIterations: whereHelperint{field: "\"service_brokers\".\"encryption_iterations\""},
    State:                whereHelperstring{field: "\"service_brokers\".\"state\""},
}
var ServiceColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Label                string
    Description          string
    InfoURL              string
    Acls                 string
    Timeout              string
    Active               string
    Extra                string
    UniqueID             string
    Bindable             string
    Tags                 string
    DocumentationURL     string
    ServiceBrokerID      string
    LongDescription      string
    Requires             string
    Purging              string
    PlanUpdateable       string
    BindingsRetrievable  string
    InstancesRetrievable string
    AllowContextUpdates  string
}{
    ID:                   "id",
    GUID:                 "guid",
    CreatedAt:            "created_at",
    UpdatedAt:            "updated_at",
    Label:                "label",
    Description:          "description",
    InfoURL:              "info_url",
    Acls:                 "acls",
    Timeout:              "timeout",
    Active:               "active",
    Extra:                "extra",
    UniqueID:             "unique_id",
    Bindable:             "bindable",
    Tags:                 "tags",
    DocumentationURL:     "documentation_url",
    ServiceBrokerID:      "service_broker_id",
    LongDescription:      "long_description",
    Requires:             "requires",
    Purging:              "purging",
    PlanUpdateable:       "plan_updateable",
    BindingsRetrievable:  "bindings_retrievable",
    InstancesRetrievable: "instances_retrievable",
    AllowContextUpdates:  "allow_context_updates",
}
var ServiceDashboardClientColumns = struct {
    ID              string
    CreatedAt       string
    UpdatedAt       string
    UaaID           string
    ServiceBrokerID string
}{
    ID:              "id",
    CreatedAt:       "created_at",
    UpdatedAt:       "updated_at",
    UaaID:           "uaa_id",
    ServiceBrokerID: "service_broker_id",
}

ServiceDashboardClientRels is where relationship names are stored.

var ServiceDashboardClientRels = struct {
}{}
var ServiceDashboardClientTableColumns = struct {
    ID              string
    CreatedAt       string
    UpdatedAt       string
    UaaID           string
    ServiceBrokerID string
}{
    ID:              "service_dashboard_clients.id",
    CreatedAt:       "service_dashboard_clients.created_at",
    UpdatedAt:       "service_dashboard_clients.updated_at",
    UaaID:           "service_dashboard_clients.uaa_id",
    ServiceBrokerID: "service_dashboard_clients.service_broker_id",
}
var ServiceDashboardClientWhere = struct {
    ID              whereHelperint
    CreatedAt       whereHelpertime_Time
    UpdatedAt       whereHelpernull_Time
    UaaID           whereHelperstring
    ServiceBrokerID whereHelpernull_Int
}{
    ID:              whereHelperint{field: "\"service_dashboard_clients\".\"id\""},
    CreatedAt:       whereHelpertime_Time{field: "\"service_dashboard_clients\".\"created_at\""},
    UpdatedAt:       whereHelpernull_Time{field: "\"service_dashboard_clients\".\"updated_at\""},
    UaaID:           whereHelperstring{field: "\"service_dashboard_clients\".\"uaa_id\""},
    ServiceBrokerID: whereHelpernull_Int{field: "\"service_dashboard_clients\".\"service_broker_id\""},
}
var ServiceInstanceAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

ServiceInstanceAnnotationRels is where relationship names are stored.

var ServiceInstanceAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceInstanceAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "service_instance_annotations.id",
    GUID:         "service_instance_annotations.guid",
    CreatedAt:    "service_instance_annotations.created_at",
    UpdatedAt:    "service_instance_annotations.updated_at",
    ResourceGUID: "service_instance_annotations.resource_guid",
    KeyPrefix:    "service_instance_annotations.key_prefix",
    Key:          "service_instance_annotations.key",
    Value:        "service_instance_annotations.value",
}
var ServiceInstanceAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_instance_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_instance_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_instance_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_instance_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_instance_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_instance_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"service_instance_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"service_instance_annotations\".\"value\""},
}
var ServiceInstanceColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    Credentials          string
    GatewayName          string
    GatewayData          string
    SpaceID              string
    ServicePlanID        string
    Salt                 string
    DashboardURL         string
    IsGatewayService     string
    SyslogDrainURL       string
    Tags                 string
    RouteServiceURL      string
    EncryptionKeyLabel   string
    EncryptionIterations string
    MaintenanceInfo      string
}{
    ID:                   "id",
    GUID:                 "guid",
    CreatedAt:            "created_at",
    UpdatedAt:            "updated_at",
    Name:                 "name",
    Credentials:          "credentials",
    GatewayName:          "gateway_name",
    GatewayData:          "gateway_data",
    SpaceID:              "space_id",
    ServicePlanID:        "service_plan_id",
    Salt:                 "salt",
    DashboardURL:         "dashboard_url",
    IsGatewayService:     "is_gateway_service",
    SyslogDrainURL:       "syslog_drain_url",
    Tags:                 "tags",
    RouteServiceURL:      "route_service_url",
    EncryptionKeyLabel:   "encryption_key_label",
    EncryptionIterations: "encryption_iterations",
    MaintenanceInfo:      "maintenance_info",
}
var ServiceInstanceLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

ServiceInstanceLabelRels is where relationship names are stored.

var ServiceInstanceLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceInstanceLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "service_instance_labels.id",
    GUID:         "service_instance_labels.guid",
    CreatedAt:    "service_instance_labels.created_at",
    UpdatedAt:    "service_instance_labels.updated_at",
    ResourceGUID: "service_instance_labels.resource_guid",
    KeyPrefix:    "service_instance_labels.key_prefix",
    KeyName:      "service_instance_labels.key_name",
    Value:        "service_instance_labels.value",
}
var ServiceInstanceLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_instance_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_instance_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_instance_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_instance_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_instance_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_instance_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"service_instance_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"service_instance_labels\".\"value\""},
}
var ServiceInstanceOperationColumns = struct {
    ID                      string
    GUID                    string
    CreatedAt               string
    UpdatedAt               string
    ServiceInstanceID       string
    Type                    string
    State                   string
    Description             string
    ProposedChanges         string
    BrokerProvidedOperation string
}{
    ID:                      "id",
    GUID:                    "guid",
    CreatedAt:               "created_at",
    UpdatedAt:               "updated_at",
    ServiceInstanceID:       "service_instance_id",
    Type:                    "type",
    State:                   "state",
    Description:             "description",
    ProposedChanges:         "proposed_changes",
    BrokerProvidedOperation: "broker_provided_operation",
}

ServiceInstanceOperationRels is where relationship names are stored.

var ServiceInstanceOperationRels = struct {
    ServiceInstance string
}{
    ServiceInstance: "ServiceInstance",
}
var ServiceInstanceOperationTableColumns = struct {
    ID                      string
    GUID                    string
    CreatedAt               string
    UpdatedAt               string
    ServiceInstanceID       string
    Type                    string
    State                   string
    Description             string
    ProposedChanges         string
    BrokerProvidedOperation string
}{
    ID:                      "service_instance_operations.id",
    GUID:                    "service_instance_operations.guid",
    CreatedAt:               "service_instance_operations.created_at",
    UpdatedAt:               "service_instance_operations.updated_at",
    ServiceInstanceID:       "service_instance_operations.service_instance_id",
    Type:                    "service_instance_operations.type",
    State:                   "service_instance_operations.state",
    Description:             "service_instance_operations.description",
    ProposedChanges:         "service_instance_operations.proposed_changes",
    BrokerProvidedOperation: "service_instance_operations.broker_provided_operation",
}
var ServiceInstanceOperationWhere = struct {
    ID                      whereHelperint
    GUID                    whereHelperstring
    CreatedAt               whereHelpertime_Time
    UpdatedAt               whereHelpernull_Time
    ServiceInstanceID       whereHelpernull_Int
    Type                    whereHelpernull_String
    State                   whereHelpernull_String
    Description             whereHelpernull_String
    ProposedChanges         whereHelperstring
    BrokerProvidedOperation whereHelpernull_String
}{
    ID:                      whereHelperint{field: "\"service_instance_operations\".\"id\""},
    GUID:                    whereHelperstring{field: "\"service_instance_operations\".\"guid\""},
    CreatedAt:               whereHelpertime_Time{field: "\"service_instance_operations\".\"created_at\""},
    UpdatedAt:               whereHelpernull_Time{field: "\"service_instance_operations\".\"updated_at\""},
    ServiceInstanceID:       whereHelpernull_Int{field: "\"service_instance_operations\".\"service_instance_id\""},
    Type:                    whereHelpernull_String{field: "\"service_instance_operations\".\"type\""},
    State:                   whereHelpernull_String{field: "\"service_instance_operations\".\"state\""},
    Description:             whereHelpernull_String{field: "\"service_instance_operations\".\"description\""},
    ProposedChanges:         whereHelperstring{field: "\"service_instance_operations\".\"proposed_changes\""},
    BrokerProvidedOperation: whereHelpernull_String{field: "\"service_instance_operations\".\"broker_provided_operation\""},
}

ServiceInstanceRels is where relationship names are stored.

var ServiceInstanceRels = struct {
    Space                              string
    ServicePlan                        string
    RouteBindings                      string
    ServiceBindings                    string
    ResourceServiceInstanceAnnotations string
    ResourceServiceInstanceLabels      string
    ServiceInstanceOperations          string
    Spaces                             string
    ServiceKeys                        string
}{
    Space:                              "Space",
    ServicePlan:                        "ServicePlan",
    RouteBindings:                      "RouteBindings",
    ServiceBindings:                    "ServiceBindings",
    ResourceServiceInstanceAnnotations: "ResourceServiceInstanceAnnotations",
    ResourceServiceInstanceLabels:      "ResourceServiceInstanceLabels",
    ServiceInstanceOperations:          "ServiceInstanceOperations",
    Spaces:                             "Spaces",
    ServiceKeys:                        "ServiceKeys",
}
var ServiceInstanceTableColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    Credentials          string
    GatewayName          string
    GatewayData          string
    SpaceID              string
    ServicePlanID        string
    Salt                 string
    DashboardURL         string
    IsGatewayService     string
    SyslogDrainURL       string
    Tags                 string
    RouteServiceURL      string
    EncryptionKeyLabel   string
    EncryptionIterations string
    MaintenanceInfo      string
}{
    ID:                   "service_instances.id",
    GUID:                 "service_instances.guid",
    CreatedAt:            "service_instances.created_at",
    UpdatedAt:            "service_instances.updated_at",
    Name:                 "service_instances.name",
    Credentials:          "service_instances.credentials",
    GatewayName:          "service_instances.gateway_name",
    GatewayData:          "service_instances.gateway_data",
    SpaceID:              "service_instances.space_id",
    ServicePlanID:        "service_instances.service_plan_id",
    Salt:                 "service_instances.salt",
    DashboardURL:         "service_instances.dashboard_url",
    IsGatewayService:     "service_instances.is_gateway_service",
    SyslogDrainURL:       "service_instances.syslog_drain_url",
    Tags:                 "service_instances.tags",
    RouteServiceURL:      "service_instances.route_service_url",
    EncryptionKeyLabel:   "service_instances.encryption_key_label",
    EncryptionIterations: "service_instances.encryption_iterations",
    MaintenanceInfo:      "service_instances.maintenance_info",
}
var ServiceInstanceWhere = struct {
    ID                   whereHelperint
    GUID                 whereHelperstring
    CreatedAt            whereHelpertime_Time
    UpdatedAt            whereHelpernull_Time
    Name                 whereHelperstring
    Credentials          whereHelpernull_String
    GatewayName          whereHelpernull_String
    GatewayData          whereHelpernull_String
    SpaceID              whereHelperint
    ServicePlanID        whereHelpernull_Int
    Salt                 whereHelpernull_String
    DashboardURL         whereHelpernull_String
    IsGatewayService     whereHelperbool
    SyslogDrainURL       whereHelpernull_String
    Tags                 whereHelpernull_String
    RouteServiceURL      whereHelpernull_String
    EncryptionKeyLabel   whereHelpernull_String
    EncryptionIterations whereHelperint
    MaintenanceInfo      whereHelpernull_String
}{
    ID:                   whereHelperint{field: "\"service_instances\".\"id\""},
    GUID:                 whereHelperstring{field: "\"service_instances\".\"guid\""},
    CreatedAt:            whereHelpertime_Time{field: "\"service_instances\".\"created_at\""},
    UpdatedAt:            whereHelpernull_Time{field: "\"service_instances\".\"updated_at\""},
    Name:                 whereHelperstring{field: "\"service_instances\".\"name\""},
    Credentials:          whereHelpernull_String{field: "\"service_instances\".\"credentials\""},
    GatewayName:          whereHelpernull_String{field: "\"service_instances\".\"gateway_name\""},
    GatewayData:          whereHelpernull_String{field: "\"service_instances\".\"gateway_data\""},
    SpaceID:              whereHelperint{field: "\"service_instances\".\"space_id\""},
    ServicePlanID:        whereHelpernull_Int{field: "\"service_instances\".\"service_plan_id\""},
    Salt:                 whereHelpernull_String{field: "\"service_instances\".\"salt\""},
    DashboardURL:         whereHelpernull_String{field: "\"service_instances\".\"dashboard_url\""},
    IsGatewayService:     whereHelperbool{field: "\"service_instances\".\"is_gateway_service\""},
    SyslogDrainURL:       whereHelpernull_String{field: "\"service_instances\".\"syslog_drain_url\""},
    Tags:                 whereHelpernull_String{field: "\"service_instances\".\"tags\""},
    RouteServiceURL:      whereHelpernull_String{field: "\"service_instances\".\"route_service_url\""},
    EncryptionKeyLabel:   whereHelpernull_String{field: "\"service_instances\".\"encryption_key_label\""},
    EncryptionIterations: whereHelperint{field: "\"service_instances\".\"encryption_iterations\""},
    MaintenanceInfo:      whereHelpernull_String{field: "\"service_instances\".\"maintenance_info\""},
}
var ServiceKeyAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

ServiceKeyAnnotationRels is where relationship names are stored.

var ServiceKeyAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceKeyAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "service_key_annotations.id",
    GUID:         "service_key_annotations.guid",
    CreatedAt:    "service_key_annotations.created_at",
    UpdatedAt:    "service_key_annotations.updated_at",
    ResourceGUID: "service_key_annotations.resource_guid",
    KeyPrefix:    "service_key_annotations.key_prefix",
    Key:          "service_key_annotations.key",
    Value:        "service_key_annotations.value",
}
var ServiceKeyAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_key_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_key_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_key_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_key_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_key_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_key_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"service_key_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"service_key_annotations\".\"value\""},
}
var ServiceKeyColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    Salt                 string
    Credentials          string
    ServiceInstanceID    string
    EncryptionKeyLabel   string
    EncryptionIterations string
}{
    ID:                   "id",
    GUID:                 "guid",
    CreatedAt:            "created_at",
    UpdatedAt:            "updated_at",
    Name:                 "name",
    Salt:                 "salt",
    Credentials:          "credentials",
    ServiceInstanceID:    "service_instance_id",
    EncryptionKeyLabel:   "encryption_key_label",
    EncryptionIterations: "encryption_iterations",
}
var ServiceKeyLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

ServiceKeyLabelRels is where relationship names are stored.

var ServiceKeyLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceKeyLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "service_key_labels.id",
    GUID:         "service_key_labels.guid",
    CreatedAt:    "service_key_labels.created_at",
    UpdatedAt:    "service_key_labels.updated_at",
    ResourceGUID: "service_key_labels.resource_guid",
    KeyPrefix:    "service_key_labels.key_prefix",
    KeyName:      "service_key_labels.key_name",
    Value:        "service_key_labels.value",
}
var ServiceKeyLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_key_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_key_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_key_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_key_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_key_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_key_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"service_key_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"service_key_labels\".\"value\""},
}
var ServiceKeyOperationColumns = struct {
    ID                      string
    CreatedAt               string
    UpdatedAt               string
    ServiceKeyID            string
    State                   string
    Type                    string
    Description             string
    BrokerProvidedOperation string
}{
    ID:                      "id",
    CreatedAt:               "created_at",
    UpdatedAt:               "updated_at",
    ServiceKeyID:            "service_key_id",
    State:                   "state",
    Type:                    "type",
    Description:             "description",
    BrokerProvidedOperation: "broker_provided_operation",
}

ServiceKeyOperationRels is where relationship names are stored.

var ServiceKeyOperationRels = struct {
    ServiceKey string
}{
    ServiceKey: "ServiceKey",
}
var ServiceKeyOperationTableColumns = struct {
    ID                      string
    CreatedAt               string
    UpdatedAt               string
    ServiceKeyID            string
    State                   string
    Type                    string
    Description             string
    BrokerProvidedOperation string
}{
    ID:                      "service_key_operations.id",
    CreatedAt:               "service_key_operations.created_at",
    UpdatedAt:               "service_key_operations.updated_at",
    ServiceKeyID:            "service_key_operations.service_key_id",
    State:                   "service_key_operations.state",
    Type:                    "service_key_operations.type",
    Description:             "service_key_operations.description",
    BrokerProvidedOperation: "service_key_operations.broker_provided_operation",
}
var ServiceKeyOperationWhere = struct {
    ID                      whereHelperint
    CreatedAt               whereHelpertime_Time
    UpdatedAt               whereHelpernull_Time
    ServiceKeyID            whereHelpernull_Int
    State                   whereHelperstring
    Type                    whereHelperstring
    Description             whereHelpernull_String
    BrokerProvidedOperation whereHelpernull_String
}{
    ID:                      whereHelperint{field: "\"service_key_operations\".\"id\""},
    CreatedAt:               whereHelpertime_Time{field: "\"service_key_operations\".\"created_at\""},
    UpdatedAt:               whereHelpernull_Time{field: "\"service_key_operations\".\"updated_at\""},
    ServiceKeyID:            whereHelpernull_Int{field: "\"service_key_operations\".\"service_key_id\""},
    State:                   whereHelperstring{field: "\"service_key_operations\".\"state\""},
    Type:                    whereHelperstring{field: "\"service_key_operations\".\"type\""},
    Description:             whereHelpernull_String{field: "\"service_key_operations\".\"description\""},
    BrokerProvidedOperation: whereHelpernull_String{field: "\"service_key_operations\".\"broker_provided_operation\""},
}

ServiceKeyRels is where relationship names are stored.

var ServiceKeyRels = struct {
    ServiceInstance               string
    ServiceKeyOperation           string
    ResourceServiceKeyAnnotations string
    ResourceServiceKeyLabels      string
}{
    ServiceInstance:               "ServiceInstance",
    ServiceKeyOperation:           "ServiceKeyOperation",
    ResourceServiceKeyAnnotations: "ResourceServiceKeyAnnotations",
    ResourceServiceKeyLabels:      "ResourceServiceKeyLabels",
}
var ServiceKeyTableColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Name                 string
    Salt                 string
    Credentials          string
    ServiceInstanceID    string
    EncryptionKeyLabel   string
    EncryptionIterations string
}{
    ID:                   "service_keys.id",
    GUID:                 "service_keys.guid",
    CreatedAt:            "service_keys.created_at",
    UpdatedAt:            "service_keys.updated_at",
    Name:                 "service_keys.name",
    Salt:                 "service_keys.salt",
    Credentials:          "service_keys.credentials",
    ServiceInstanceID:    "service_keys.service_instance_id",
    EncryptionKeyLabel:   "service_keys.encryption_key_label",
    EncryptionIterations: "service_keys.encryption_iterations",
}
var ServiceKeyWhere = struct {
    ID                   whereHelperint
    GUID                 whereHelperstring
    CreatedAt            whereHelpertime_Time
    UpdatedAt            whereHelpernull_Time
    Name                 whereHelperstring
    Salt                 whereHelpernull_String
    Credentials          whereHelperstring
    ServiceInstanceID    whereHelperint
    EncryptionKeyLabel   whereHelpernull_String
    EncryptionIterations whereHelperint
}{
    ID:                   whereHelperint{field: "\"service_keys\".\"id\""},
    GUID:                 whereHelperstring{field: "\"service_keys\".\"guid\""},
    CreatedAt:            whereHelpertime_Time{field: "\"service_keys\".\"created_at\""},
    UpdatedAt:            whereHelpernull_Time{field: "\"service_keys\".\"updated_at\""},
    Name:                 whereHelperstring{field: "\"service_keys\".\"name\""},
    Salt:                 whereHelpernull_String{field: "\"service_keys\".\"salt\""},
    Credentials:          whereHelperstring{field: "\"service_keys\".\"credentials\""},
    ServiceInstanceID:    whereHelperint{field: "\"service_keys\".\"service_instance_id\""},
    EncryptionKeyLabel:   whereHelpernull_String{field: "\"service_keys\".\"encryption_key_label\""},
    EncryptionIterations: whereHelperint{field: "\"service_keys\".\"encryption_iterations\""},
}
var ServiceOfferingAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

ServiceOfferingAnnotationRels is where relationship names are stored.

var ServiceOfferingAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceOfferingAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "service_offering_annotations.id",
    GUID:         "service_offering_annotations.guid",
    CreatedAt:    "service_offering_annotations.created_at",
    UpdatedAt:    "service_offering_annotations.updated_at",
    ResourceGUID: "service_offering_annotations.resource_guid",
    KeyPrefix:    "service_offering_annotations.key_prefix",
    Key:          "service_offering_annotations.key",
    Value:        "service_offering_annotations.value",
}
var ServiceOfferingAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_offering_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_offering_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_offering_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_offering_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_offering_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_offering_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"service_offering_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"service_offering_annotations\".\"value\""},
}
var ServiceOfferingLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

ServiceOfferingLabelRels is where relationship names are stored.

var ServiceOfferingLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServiceOfferingLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "service_offering_labels.id",
    GUID:         "service_offering_labels.guid",
    CreatedAt:    "service_offering_labels.created_at",
    UpdatedAt:    "service_offering_labels.updated_at",
    ResourceGUID: "service_offering_labels.resource_guid",
    KeyPrefix:    "service_offering_labels.key_prefix",
    KeyName:      "service_offering_labels.key_name",
    Value:        "service_offering_labels.value",
}
var ServiceOfferingLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_offering_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_offering_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_offering_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_offering_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_offering_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_offering_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"service_offering_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"service_offering_labels\".\"value\""},
}
var ServicePlanAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

ServicePlanAnnotationRels is where relationship names are stored.

var ServicePlanAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServicePlanAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "service_plan_annotations.id",
    GUID:         "service_plan_annotations.guid",
    CreatedAt:    "service_plan_annotations.created_at",
    UpdatedAt:    "service_plan_annotations.updated_at",
    ResourceGUID: "service_plan_annotations.resource_guid",
    KeyPrefix:    "service_plan_annotations.key_prefix",
    Key:          "service_plan_annotations.key",
    Value:        "service_plan_annotations.value",
}
var ServicePlanAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_plan_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_plan_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_plan_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_plan_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_plan_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_plan_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"service_plan_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"service_plan_annotations\".\"value\""},
}
var ServicePlanColumns = struct {
    ID                     string
    GUID                   string
    CreatedAt              string
    UpdatedAt              string
    Name                   string
    Description            string
    Free                   string
    ServiceID              string
    Extra                  string
    UniqueID               string
    Public                 string
    Active                 string
    Bindable               string
    CreateInstanceSchema   string
    UpdateInstanceSchema   string
    CreateBindingSchema    string
    PlanUpdateable         string
    MaximumPollingDuration string
    MaintenanceInfo        string
}{
    ID:                     "id",
    GUID:                   "guid",
    CreatedAt:              "created_at",
    UpdatedAt:              "updated_at",
    Name:                   "name",
    Description:            "description",
    Free:                   "free",
    ServiceID:              "service_id",
    Extra:                  "extra",
    UniqueID:               "unique_id",
    Public:                 "public",
    Active:                 "active",
    Bindable:               "bindable",
    CreateInstanceSchema:   "create_instance_schema",
    UpdateInstanceSchema:   "update_instance_schema",
    CreateBindingSchema:    "create_binding_schema",
    PlanUpdateable:         "plan_updateable",
    MaximumPollingDuration: "maximum_polling_duration",
    MaintenanceInfo:        "maintenance_info",
}
var ServicePlanLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

ServicePlanLabelRels is where relationship names are stored.

var ServicePlanLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var ServicePlanLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "service_plan_labels.id",
    GUID:         "service_plan_labels.guid",
    CreatedAt:    "service_plan_labels.created_at",
    UpdatedAt:    "service_plan_labels.updated_at",
    ResourceGUID: "service_plan_labels.resource_guid",
    KeyPrefix:    "service_plan_labels.key_prefix",
    KeyName:      "service_plan_labels.key_name",
    Value:        "service_plan_labels.value",
}
var ServicePlanLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"service_plan_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"service_plan_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"service_plan_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"service_plan_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"service_plan_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"service_plan_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"service_plan_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"service_plan_labels\".\"value\""},
}

ServicePlanRels is where relationship names are stored.

var ServicePlanRels = struct {
    Service                        string
    ServiceInstances               string
    ResourceServicePlanAnnotations string
    ResourceServicePlanLabels      string
    ServicePlanVisibilities        string
}{
    Service:                        "Service",
    ServiceInstances:               "ServiceInstances",
    ResourceServicePlanAnnotations: "ResourceServicePlanAnnotations",
    ResourceServicePlanLabels:      "ResourceServicePlanLabels",
    ServicePlanVisibilities:        "ServicePlanVisibilities",
}
var ServicePlanTableColumns = struct {
    ID                     string
    GUID                   string
    CreatedAt              string
    UpdatedAt              string
    Name                   string
    Description            string
    Free                   string
    ServiceID              string
    Extra                  string
    UniqueID               string
    Public                 string
    Active                 string
    Bindable               string
    CreateInstanceSchema   string
    UpdateInstanceSchema   string
    CreateBindingSchema    string
    PlanUpdateable         string
    MaximumPollingDuration string
    MaintenanceInfo        string
}{
    ID:                     "service_plans.id",
    GUID:                   "service_plans.guid",
    CreatedAt:              "service_plans.created_at",
    UpdatedAt:              "service_plans.updated_at",
    Name:                   "service_plans.name",
    Description:            "service_plans.description",
    Free:                   "service_plans.free",
    ServiceID:              "service_plans.service_id",
    Extra:                  "service_plans.extra",
    UniqueID:               "service_plans.unique_id",
    Public:                 "service_plans.public",
    Active:                 "service_plans.active",
    Bindable:               "service_plans.bindable",
    CreateInstanceSchema:   "service_plans.create_instance_schema",
    UpdateInstanceSchema:   "service_plans.update_instance_schema",
    CreateBindingSchema:    "service_plans.create_binding_schema",
    PlanUpdateable:         "service_plans.plan_updateable",
    MaximumPollingDuration: "service_plans.maximum_polling_duration",
    MaintenanceInfo:        "service_plans.maintenance_info",
}
var ServicePlanVisibilityColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    ServicePlanID  string
    OrganizationID string
}{
    ID:             "id",
    GUID:           "guid",
    CreatedAt:      "created_at",
    UpdatedAt:      "updated_at",
    ServicePlanID:  "service_plan_id",
    OrganizationID: "organization_id",
}

ServicePlanVisibilityRels is where relationship names are stored.

var ServicePlanVisibilityRels = struct {
    Organization string
    ServicePlan  string
}{
    Organization: "Organization",
    ServicePlan:  "ServicePlan",
}
var ServicePlanVisibilityTableColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    ServicePlanID  string
    OrganizationID string
}{
    ID:             "service_plan_visibilities.id",
    GUID:           "service_plan_visibilities.guid",
    CreatedAt:      "service_plan_visibilities.created_at",
    UpdatedAt:      "service_plan_visibilities.updated_at",
    ServicePlanID:  "service_plan_visibilities.service_plan_id",
    OrganizationID: "service_plan_visibilities.organization_id",
}
var ServicePlanVisibilityWhere = struct {
    ID             whereHelperint
    GUID           whereHelperstring
    CreatedAt      whereHelpertime_Time
    UpdatedAt      whereHelpernull_Time
    ServicePlanID  whereHelperint
    OrganizationID whereHelperint
}{
    ID:             whereHelperint{field: "\"service_plan_visibilities\".\"id\""},
    GUID:           whereHelperstring{field: "\"service_plan_visibilities\".\"guid\""},
    CreatedAt:      whereHelpertime_Time{field: "\"service_plan_visibilities\".\"created_at\""},
    UpdatedAt:      whereHelpernull_Time{field: "\"service_plan_visibilities\".\"updated_at\""},
    ServicePlanID:  whereHelperint{field: "\"service_plan_visibilities\".\"service_plan_id\""},
    OrganizationID: whereHelperint{field: "\"service_plan_visibilities\".\"organization_id\""},
}
var ServicePlanWhere = struct {
    ID                     whereHelperint
    GUID                   whereHelperstring
    CreatedAt              whereHelpertime_Time
    UpdatedAt              whereHelpernull_Time
    Name                   whereHelperstring
    Description            whereHelperstring
    Free                   whereHelperbool
    ServiceID              whereHelperint
    Extra                  whereHelpernull_String
    UniqueID               whereHelperstring
    Public                 whereHelpernull_Bool
    Active                 whereHelpernull_Bool
    Bindable               whereHelpernull_Bool
    CreateInstanceSchema   whereHelpernull_String
    UpdateInstanceSchema   whereHelpernull_String
    CreateBindingSchema    whereHelpernull_String
    PlanUpdateable         whereHelpernull_Bool
    MaximumPollingDuration whereHelpernull_Int
    MaintenanceInfo        whereHelpernull_String
}{
    ID:                     whereHelperint{field: "\"service_plans\".\"id\""},
    GUID:                   whereHelperstring{field: "\"service_plans\".\"guid\""},
    CreatedAt:              whereHelpertime_Time{field: "\"service_plans\".\"created_at\""},
    UpdatedAt:              whereHelpernull_Time{field: "\"service_plans\".\"updated_at\""},
    Name:                   whereHelperstring{field: "\"service_plans\".\"name\""},
    Description:            whereHelperstring{field: "\"service_plans\".\"description\""},
    Free:                   whereHelperbool{field: "\"service_plans\".\"free\""},
    ServiceID:              whereHelperint{field: "\"service_plans\".\"service_id\""},
    Extra:                  whereHelpernull_String{field: "\"service_plans\".\"extra\""},
    UniqueID:               whereHelperstring{field: "\"service_plans\".\"unique_id\""},
    Public:                 whereHelpernull_Bool{field: "\"service_plans\".\"public\""},
    Active:                 whereHelpernull_Bool{field: "\"service_plans\".\"active\""},
    Bindable:               whereHelpernull_Bool{field: "\"service_plans\".\"bindable\""},
    CreateInstanceSchema:   whereHelpernull_String{field: "\"service_plans\".\"create_instance_schema\""},
    UpdateInstanceSchema:   whereHelpernull_String{field: "\"service_plans\".\"update_instance_schema\""},
    CreateBindingSchema:    whereHelpernull_String{field: "\"service_plans\".\"create_binding_schema\""},
    PlanUpdateable:         whereHelpernull_Bool{field: "\"service_plans\".\"plan_updateable\""},
    MaximumPollingDuration: whereHelpernull_Int{field: "\"service_plans\".\"maximum_polling_duration\""},
    MaintenanceInfo:        whereHelpernull_String{field: "\"service_plans\".\"maintenance_info\""},
}

ServiceRels is where relationship names are stored.

var ServiceRels = struct {
    ServiceBroker                      string
    ResourceServiceOfferingAnnotations string
    ResourceServiceOfferingLabels      string
    ServicePlans                       string
}{
    ServiceBroker:                      "ServiceBroker",
    ResourceServiceOfferingAnnotations: "ResourceServiceOfferingAnnotations",
    ResourceServiceOfferingLabels:      "ResourceServiceOfferingLabels",
    ServicePlans:                       "ServicePlans",
}
var ServiceTableColumns = struct {
    ID                   string
    GUID                 string
    CreatedAt            string
    UpdatedAt            string
    Label                string
    Description          string
    InfoURL              string
    Acls                 string
    Timeout              string
    Active               string
    Extra                string
    UniqueID             string
    Bindable             string
    Tags                 string
    DocumentationURL     string
    ServiceBrokerID      string
    LongDescription      string
    Requires             string
    Purging              string
    PlanUpdateable       string
    BindingsRetrievable  string
    InstancesRetrievable string
    AllowContextUpdates  string
}{
    ID:                   "services.id",
    GUID:                 "services.guid",
    CreatedAt:            "services.created_at",
    UpdatedAt:            "services.updated_at",
    Label:                "services.label",
    Description:          "services.description",
    InfoURL:              "services.info_url",
    Acls:                 "services.acls",
    Timeout:              "services.timeout",
    Active:               "services.active",
    Extra:                "services.extra",
    UniqueID:             "services.unique_id",
    Bindable:             "services.bindable",
    Tags:                 "services.tags",
    DocumentationURL:     "services.documentation_url",
    ServiceBrokerID:      "services.service_broker_id",
    LongDescription:      "services.long_description",
    Requires:             "services.requires",
    Purging:              "services.purging",
    PlanUpdateable:       "services.plan_updateable",
    BindingsRetrievable:  "services.bindings_retrievable",
    InstancesRetrievable: "services.instances_retrievable",
    AllowContextUpdates:  "services.allow_context_updates",
}
var ServiceUsageEventColumns = struct {
    ID                  string
    GUID                string
    CreatedAt           string
    State               string
    OrgGUID             string
    SpaceGUID           string
    SpaceName           string
    ServiceInstanceGUID string
    ServiceInstanceName string
    ServiceInstanceType string
    ServicePlanGUID     string
    ServicePlanName     string
    ServiceGUID         string
    ServiceLabel        string
    ServiceBrokerName   string
    ServiceBrokerGUID   string
}{
    ID:                  "id",
    GUID:                "guid",
    CreatedAt:           "created_at",
    State:               "state",
    OrgGUID:             "org_guid",
    SpaceGUID:           "space_guid",
    SpaceName:           "space_name",
    ServiceInstanceGUID: "service_instance_guid",
    ServiceInstanceName: "service_instance_name",
    ServiceInstanceType: "service_instance_type",
    ServicePlanGUID:     "service_plan_guid",
    ServicePlanName:     "service_plan_name",
    ServiceGUID:         "service_guid",
    ServiceLabel:        "service_label",
    ServiceBrokerName:   "service_broker_name",
    ServiceBrokerGUID:   "service_broker_guid",
}

ServiceUsageEventRels is where relationship names are stored.

var ServiceUsageEventRels = struct {
}{}
var ServiceUsageEventTableColumns = struct {
    ID                  string
    GUID                string
    CreatedAt           string
    State               string
    OrgGUID             string
    SpaceGUID           string
    SpaceName           string
    ServiceInstanceGUID string
    ServiceInstanceName string
    ServiceInstanceType string
    ServicePlanGUID     string
    ServicePlanName     string
    ServiceGUID         string
    ServiceLabel        string
    ServiceBrokerName   string
    ServiceBrokerGUID   string
}{
    ID:                  "service_usage_events.id",
    GUID:                "service_usage_events.guid",
    CreatedAt:           "service_usage_events.created_at",
    State:               "service_usage_events.state",
    OrgGUID:             "service_usage_events.org_guid",
    SpaceGUID:           "service_usage_events.space_guid",
    SpaceName:           "service_usage_events.space_name",
    ServiceInstanceGUID: "service_usage_events.service_instance_guid",
    ServiceInstanceName: "service_usage_events.service_instance_name",
    ServiceInstanceType: "service_usage_events.service_instance_type",
    ServicePlanGUID:     "service_usage_events.service_plan_guid",
    ServicePlanName:     "service_usage_events.service_plan_name",
    ServiceGUID:         "service_usage_events.service_guid",
    ServiceLabel:        "service_usage_events.service_label",
    ServiceBrokerName:   "service_usage_events.service_broker_name",
    ServiceBrokerGUID:   "service_usage_events.service_broker_guid",
}
var ServiceUsageEventWhere = struct {
    ID                  whereHelperint
    GUID                whereHelperstring
    CreatedAt           whereHelpertime_Time
    State               whereHelperstring
    OrgGUID             whereHelperstring
    SpaceGUID           whereHelperstring
    SpaceName           whereHelperstring
    ServiceInstanceGUID whereHelperstring
    ServiceInstanceName whereHelperstring
    ServiceInstanceType whereHelperstring
    ServicePlanGUID     whereHelpernull_String
    ServicePlanName     whereHelpernull_String
    ServiceGUID         whereHelpernull_String
    ServiceLabel        whereHelpernull_String
    ServiceBrokerName   whereHelpernull_String
    ServiceBrokerGUID   whereHelpernull_String
}{
    ID:                  whereHelperint{field: "\"service_usage_events\".\"id\""},
    GUID:                whereHelperstring{field: "\"service_usage_events\".\"guid\""},
    CreatedAt:           whereHelpertime_Time{field: "\"service_usage_events\".\"created_at\""},
    State:               whereHelperstring{field: "\"service_usage_events\".\"state\""},
    OrgGUID:             whereHelperstring{field: "\"service_usage_events\".\"org_guid\""},
    SpaceGUID:           whereHelperstring{field: "\"service_usage_events\".\"space_guid\""},
    SpaceName:           whereHelperstring{field: "\"service_usage_events\".\"space_name\""},
    ServiceInstanceGUID: whereHelperstring{field: "\"service_usage_events\".\"service_instance_guid\""},
    ServiceInstanceName: whereHelperstring{field: "\"service_usage_events\".\"service_instance_name\""},
    ServiceInstanceType: whereHelperstring{field: "\"service_usage_events\".\"service_instance_type\""},
    ServicePlanGUID:     whereHelpernull_String{field: "\"service_usage_events\".\"service_plan_guid\""},
    ServicePlanName:     whereHelpernull_String{field: "\"service_usage_events\".\"service_plan_name\""},
    ServiceGUID:         whereHelpernull_String{field: "\"service_usage_events\".\"service_guid\""},
    ServiceLabel:        whereHelpernull_String{field: "\"service_usage_events\".\"service_label\""},
    ServiceBrokerName:   whereHelpernull_String{field: "\"service_usage_events\".\"service_broker_name\""},
    ServiceBrokerGUID:   whereHelpernull_String{field: "\"service_usage_events\".\"service_broker_guid\""},
}
var ServiceWhere = struct {
    ID                   whereHelperint
    GUID                 whereHelperstring
    CreatedAt            whereHelpertime_Time
    UpdatedAt            whereHelpernull_Time
    Label                whereHelperstring
    Description          whereHelperstring
    InfoURL              whereHelpernull_String
    Acls                 whereHelpernull_String
    Timeout              whereHelpernull_Int
    Active               whereHelpernull_Bool
    Extra                whereHelpernull_String
    UniqueID             whereHelpernull_String
    Bindable             whereHelperbool
    Tags                 whereHelpernull_String
    DocumentationURL     whereHelpernull_String
    ServiceBrokerID      whereHelpernull_Int
    LongDescription      whereHelpernull_String
    Requires             whereHelpernull_String
    Purging              whereHelperbool
    PlanUpdateable       whereHelpernull_Bool
    BindingsRetrievable  whereHelperbool
    InstancesRetrievable whereHelperbool
    AllowContextUpdates  whereHelperbool
}{
    ID:                   whereHelperint{field: "\"services\".\"id\""},
    GUID:                 whereHelperstring{field: "\"services\".\"guid\""},
    CreatedAt:            whereHelpertime_Time{field: "\"services\".\"created_at\""},
    UpdatedAt:            whereHelpernull_Time{field: "\"services\".\"updated_at\""},
    Label:                whereHelperstring{field: "\"services\".\"label\""},
    Description:          whereHelperstring{field: "\"services\".\"description\""},
    InfoURL:              whereHelpernull_String{field: "\"services\".\"info_url\""},
    Acls:                 whereHelpernull_String{field: "\"services\".\"acls\""},
    Timeout:              whereHelpernull_Int{field: "\"services\".\"timeout\""},
    Active:               whereHelpernull_Bool{field: "\"services\".\"active\""},
    Extra:                whereHelpernull_String{field: "\"services\".\"extra\""},
    UniqueID:             whereHelpernull_String{field: "\"services\".\"unique_id\""},
    Bindable:             whereHelperbool{field: "\"services\".\"bindable\""},
    Tags:                 whereHelpernull_String{field: "\"services\".\"tags\""},
    DocumentationURL:     whereHelpernull_String{field: "\"services\".\"documentation_url\""},
    ServiceBrokerID:      whereHelpernull_Int{field: "\"services\".\"service_broker_id\""},
    LongDescription:      whereHelpernull_String{field: "\"services\".\"long_description\""},
    Requires:             whereHelpernull_String{field: "\"services\".\"requires\""},
    Purging:              whereHelperbool{field: "\"services\".\"purging\""},
    PlanUpdateable:       whereHelpernull_Bool{field: "\"services\".\"plan_updateable\""},
    BindingsRetrievable:  whereHelperbool{field: "\"services\".\"bindings_retrievable\""},
    InstancesRetrievable: whereHelperbool{field: "\"services\".\"instances_retrievable\""},
    AllowContextUpdates:  whereHelperbool{field: "\"services\".\"allow_context_updates\""},
}
var SidecarColumns = struct {
    ID        string
    GUID      string
    CreatedAt string
    UpdatedAt string
    Name      string
    Command   string
    AppGUID   string
    Memory    string
    Origin    string
}{
    ID:        "id",
    GUID:      "guid",
    CreatedAt: "created_at",
    UpdatedAt: "updated_at",
    Name:      "name",
    Command:   "command",
    AppGUID:   "app_guid",
    Memory:    "memory",
    Origin:    "origin",
}
var SidecarProcessTypeColumns = struct {
    ID          string
    GUID        string
    CreatedAt   string
    UpdatedAt   string
    Type        string
    SidecarGUID string
    AppGUID     string
}{
    ID:          "id",
    GUID:        "guid",
    CreatedAt:   "created_at",
    UpdatedAt:   "updated_at",
    Type:        "type",
    SidecarGUID: "sidecar_guid",
    AppGUID:     "app_guid",
}

SidecarProcessTypeRels is where relationship names are stored.

var SidecarProcessTypeRels = struct {
    Sidecar string
}{
    Sidecar: "Sidecar",
}
var SidecarProcessTypeTableColumns = struct {
    ID          string
    GUID        string
    CreatedAt   string
    UpdatedAt   string
    Type        string
    SidecarGUID string
    AppGUID     string
}{
    ID:          "sidecar_process_types.id",
    GUID:        "sidecar_process_types.guid",
    CreatedAt:   "sidecar_process_types.created_at",
    UpdatedAt:   "sidecar_process_types.updated_at",
    Type:        "sidecar_process_types.type",
    SidecarGUID: "sidecar_process_types.sidecar_guid",
    AppGUID:     "sidecar_process_types.app_guid",
}
var SidecarProcessTypeWhere = struct {
    ID          whereHelperint
    GUID        whereHelperstring
    CreatedAt   whereHelpertime_Time
    UpdatedAt   whereHelpernull_Time
    Type        whereHelperstring
    SidecarGUID whereHelperstring
    AppGUID     whereHelperstring
}{
    ID:          whereHelperint{field: "\"sidecar_process_types\".\"id\""},
    GUID:        whereHelperstring{field: "\"sidecar_process_types\".\"guid\""},
    CreatedAt:   whereHelpertime_Time{field: "\"sidecar_process_types\".\"created_at\""},
    UpdatedAt:   whereHelpernull_Time{field: "\"sidecar_process_types\".\"updated_at\""},
    Type:        whereHelperstring{field: "\"sidecar_process_types\".\"type\""},
    SidecarGUID: whereHelperstring{field: "\"sidecar_process_types\".\"sidecar_guid\""},
    AppGUID:     whereHelperstring{field: "\"sidecar_process_types\".\"app_guid\""},
}

SidecarRels is where relationship names are stored.

var SidecarRels = struct {
    App                 string
    SidecarProcessTypes string
}{
    App:                 "App",
    SidecarProcessTypes: "SidecarProcessTypes",
}
var SidecarTableColumns = struct {
    ID        string
    GUID      string
    CreatedAt string
    UpdatedAt string
    Name      string
    Command   string
    AppGUID   string
    Memory    string
    Origin    string
}{
    ID:        "sidecars.id",
    GUID:      "sidecars.guid",
    CreatedAt: "sidecars.created_at",
    UpdatedAt: "sidecars.updated_at",
    Name:      "sidecars.name",
    Command:   "sidecars.command",
    AppGUID:   "sidecars.app_guid",
    Memory:    "sidecars.memory",
    Origin:    "sidecars.origin",
}
var SidecarWhere = struct {
    ID        whereHelperint
    GUID      whereHelperstring
    CreatedAt whereHelpertime_Time
    UpdatedAt whereHelpernull_Time
    Name      whereHelperstring
    Command   whereHelperstring
    AppGUID   whereHelperstring
    Memory    whereHelpernull_Int
    Origin    whereHelperstring
}{
    ID:        whereHelperint{field: "\"sidecars\".\"id\""},
    GUID:      whereHelperstring{field: "\"sidecars\".\"guid\""},
    CreatedAt: whereHelpertime_Time{field: "\"sidecars\".\"created_at\""},
    UpdatedAt: whereHelpernull_Time{field: "\"sidecars\".\"updated_at\""},
    Name:      whereHelperstring{field: "\"sidecars\".\"name\""},
    Command:   whereHelperstring{field: "\"sidecars\".\"command\""},
    AppGUID:   whereHelperstring{field: "\"sidecars\".\"app_guid\""},
    Memory:    whereHelpernull_Int{field: "\"sidecars\".\"memory\""},
    Origin:    whereHelperstring{field: "\"sidecars\".\"origin\""},
}
var SpaceAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

SpaceAnnotationRels is where relationship names are stored.

var SpaceAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var SpaceAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "space_annotations.id",
    GUID:         "space_annotations.guid",
    CreatedAt:    "space_annotations.created_at",
    UpdatedAt:    "space_annotations.updated_at",
    ResourceGUID: "space_annotations.resource_guid",
    KeyPrefix:    "space_annotations.key_prefix",
    Key:          "space_annotations.key",
    Value:        "space_annotations.value",
}
var SpaceAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"space_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"space_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"space_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"space_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"space_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"space_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"space_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"space_annotations\".\"value\""},
}
var SpaceColumns = struct {
    ID                     string
    GUID                   string
    CreatedAt              string
    UpdatedAt              string
    Name                   string
    OrganizationID         string
    SpaceQuotaDefinitionID string
    AllowSSH               string
    IsolationSegmentGUID   string
}{
    ID:                     "id",
    GUID:                   "guid",
    CreatedAt:              "created_at",
    UpdatedAt:              "updated_at",
    Name:                   "name",
    OrganizationID:         "organization_id",
    SpaceQuotaDefinitionID: "space_quota_definition_id",
    AllowSSH:               "allow_ssh",
    IsolationSegmentGUID:   "isolation_segment_guid",
}
var SpaceLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

SpaceLabelRels is where relationship names are stored.

var SpaceLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var SpaceLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "space_labels.id",
    GUID:         "space_labels.guid",
    CreatedAt:    "space_labels.created_at",
    UpdatedAt:    "space_labels.updated_at",
    ResourceGUID: "space_labels.resource_guid",
    KeyPrefix:    "space_labels.key_prefix",
    KeyName:      "space_labels.key_name",
    Value:        "space_labels.value",
}
var SpaceLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"space_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"space_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"space_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"space_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"space_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"space_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"space_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"space_labels\".\"value\""},
}
var SpaceQuotaDefinitionColumns = struct {
    ID                      string
    GUID                    string
    CreatedAt               string
    UpdatedAt               string
    Name                    string
    NonBasicServicesAllowed string
    TotalServices           string
    MemoryLimit             string
    TotalRoutes             string
    InstanceMemoryLimit     string
    OrganizationID          string
    AppInstanceLimit        string
    AppTaskLimit            string
    TotalServiceKeys        string
    TotalReservedRoutePorts string
}{
    ID:                      "id",
    GUID:                    "guid",
    CreatedAt:               "created_at",
    UpdatedAt:               "updated_at",
    Name:                    "name",
    NonBasicServicesAllowed: "non_basic_services_allowed",
    TotalServices:           "total_services",
    MemoryLimit:             "memory_limit",
    TotalRoutes:             "total_routes",
    InstanceMemoryLimit:     "instance_memory_limit",
    OrganizationID:          "organization_id",
    AppInstanceLimit:        "app_instance_limit",
    AppTaskLimit:            "app_task_limit",
    TotalServiceKeys:        "total_service_keys",
    TotalReservedRoutePorts: "total_reserved_route_ports",
}

SpaceQuotaDefinitionRels is where relationship names are stored.

var SpaceQuotaDefinitionRels = struct {
    Organization string
    Spaces       string
}{
    Organization: "Organization",
    Spaces:       "Spaces",
}
var SpaceQuotaDefinitionTableColumns = struct {
    ID                      string
    GUID                    string
    CreatedAt               string
    UpdatedAt               string
    Name                    string
    NonBasicServicesAllowed string
    TotalServices           string
    MemoryLimit             string
    TotalRoutes             string
    InstanceMemoryLimit     string
    OrganizationID          string
    AppInstanceLimit        string
    AppTaskLimit            string
    TotalServiceKeys        string
    TotalReservedRoutePorts string
}{
    ID:                      "space_quota_definitions.id",
    GUID:                    "space_quota_definitions.guid",
    CreatedAt:               "space_quota_definitions.created_at",
    UpdatedAt:               "space_quota_definitions.updated_at",
    Name:                    "space_quota_definitions.name",
    NonBasicServicesAllowed: "space_quota_definitions.non_basic_services_allowed",
    TotalServices:           "space_quota_definitions.total_services",
    MemoryLimit:             "space_quota_definitions.memory_limit",
    TotalRoutes:             "space_quota_definitions.total_routes",
    InstanceMemoryLimit:     "space_quota_definitions.instance_memory_limit",
    OrganizationID:          "space_quota_definitions.organization_id",
    AppInstanceLimit:        "space_quota_definitions.app_instance_limit",
    AppTaskLimit:            "space_quota_definitions.app_task_limit",
    TotalServiceKeys:        "space_quota_definitions.total_service_keys",
    TotalReservedRoutePorts: "space_quota_definitions.total_reserved_route_ports",
}
var SpaceQuotaDefinitionWhere = struct {
    ID                      whereHelperint
    GUID                    whereHelperstring
    CreatedAt               whereHelpertime_Time
    UpdatedAt               whereHelpernull_Time
    Name                    whereHelperstring
    NonBasicServicesAllowed whereHelperbool
    TotalServices           whereHelperint
    MemoryLimit             whereHelperint
    TotalRoutes             whereHelperint
    InstanceMemoryLimit     whereHelperint
    OrganizationID          whereHelperint
    AppInstanceLimit        whereHelpernull_Int
    AppTaskLimit            whereHelpernull_Int
    TotalServiceKeys        whereHelperint
    TotalReservedRoutePorts whereHelpernull_Int
}{
    ID:                      whereHelperint{field: "\"space_quota_definitions\".\"id\""},
    GUID:                    whereHelperstring{field: "\"space_quota_definitions\".\"guid\""},
    CreatedAt:               whereHelpertime_Time{field: "\"space_quota_definitions\".\"created_at\""},
    UpdatedAt:               whereHelpernull_Time{field: "\"space_quota_definitions\".\"updated_at\""},
    Name:                    whereHelperstring{field: "\"space_quota_definitions\".\"name\""},
    NonBasicServicesAllowed: whereHelperbool{field: "\"space_quota_definitions\".\"non_basic_services_allowed\""},
    TotalServices:           whereHelperint{field: "\"space_quota_definitions\".\"total_services\""},
    MemoryLimit:             whereHelperint{field: "\"space_quota_definitions\".\"memory_limit\""},
    TotalRoutes:             whereHelperint{field: "\"space_quota_definitions\".\"total_routes\""},
    InstanceMemoryLimit:     whereHelperint{field: "\"space_quota_definitions\".\"instance_memory_limit\""},
    OrganizationID:          whereHelperint{field: "\"space_quota_definitions\".\"organization_id\""},
    AppInstanceLimit:        whereHelpernull_Int{field: "\"space_quota_definitions\".\"app_instance_limit\""},
    AppTaskLimit:            whereHelpernull_Int{field: "\"space_quota_definitions\".\"app_task_limit\""},
    TotalServiceKeys:        whereHelperint{field: "\"space_quota_definitions\".\"total_service_keys\""},
    TotalReservedRoutePorts: whereHelpernull_Int{field: "\"space_quota_definitions\".\"total_reserved_route_ports\""},
}

SpaceRels is where relationship names are stored.

var SpaceRels = struct {
    SpaceQuotaDefinition                    string
    IsolationSegment                        string
    Organization                            string
    Apps                                    string
    Routes                                  string
    SecurityGroupsSpaces                    string
    ServiceBrokers                          string
    SharedServiceInstances                  string
    ServiceInstances                        string
    ResourceSpaceAnnotations                string
    ResourceSpaceLabels                     string
    SpacesApplicationSupporters             string
    SpacesAuditors                          string
    SpacesDevelopers                        string
    SpacesManagers                          string
    StagingSpaceStagingSecurityGroupsSpaces string
    DefaultSpaceUsers                       string
}{
    SpaceQuotaDefinition:                    "SpaceQuotaDefinition",
    IsolationSegment:                        "IsolationSegment",
    Organization:                            "Organization",
    Apps:                                    "Apps",
    Routes:                                  "Routes",
    SecurityGroupsSpaces:                    "SecurityGroupsSpaces",
    ServiceBrokers:                          "ServiceBrokers",
    SharedServiceInstances:                  "SharedServiceInstances",
    ServiceInstances:                        "ServiceInstances",
    ResourceSpaceAnnotations:                "ResourceSpaceAnnotations",
    ResourceSpaceLabels:                     "ResourceSpaceLabels",
    SpacesApplicationSupporters:             "SpacesApplicationSupporters",
    SpacesAuditors:                          "SpacesAuditors",
    SpacesDevelopers:                        "SpacesDevelopers",
    SpacesManagers:                          "SpacesManagers",
    StagingSpaceStagingSecurityGroupsSpaces: "StagingSpaceStagingSecurityGroupsSpaces",
    DefaultSpaceUsers:                       "DefaultSpaceUsers",
}
var SpaceTableColumns = struct {
    ID                     string
    GUID                   string
    CreatedAt              string
    UpdatedAt              string
    Name                   string
    OrganizationID         string
    SpaceQuotaDefinitionID string
    AllowSSH               string
    IsolationSegmentGUID   string
}{
    ID:                     "spaces.id",
    GUID:                   "spaces.guid",
    CreatedAt:              "spaces.created_at",
    UpdatedAt:              "spaces.updated_at",
    Name:                   "spaces.name",
    OrganizationID:         "spaces.organization_id",
    SpaceQuotaDefinitionID: "spaces.space_quota_definition_id",
    AllowSSH:               "spaces.allow_ssh",
    IsolationSegmentGUID:   "spaces.isolation_segment_guid",
}
var SpaceWhere = struct {
    ID                     whereHelperint
    GUID                   whereHelperstring
    CreatedAt              whereHelpertime_Time
    UpdatedAt              whereHelpernull_Time
    Name                   whereHelperstring
    OrganizationID         whereHelperint
    SpaceQuotaDefinitionID whereHelpernull_Int
    AllowSSH               whereHelpernull_Bool
    IsolationSegmentGUID   whereHelpernull_String
}{
    ID:                     whereHelperint{field: "\"spaces\".\"id\""},
    GUID:                   whereHelperstring{field: "\"spaces\".\"guid\""},
    CreatedAt:              whereHelpertime_Time{field: "\"spaces\".\"created_at\""},
    UpdatedAt:              whereHelpernull_Time{field: "\"spaces\".\"updated_at\""},
    Name:                   whereHelperstring{field: "\"spaces\".\"name\""},
    OrganizationID:         whereHelperint{field: "\"spaces\".\"organization_id\""},
    SpaceQuotaDefinitionID: whereHelpernull_Int{field: "\"spaces\".\"space_quota_definition_id\""},
    AllowSSH:               whereHelpernull_Bool{field: "\"spaces\".\"allow_ssh\""},
    IsolationSegmentGUID:   whereHelpernull_String{field: "\"spaces\".\"isolation_segment_guid\""},
}
var SpacesApplicationSupporterColumns = struct {
    SpacesApplicationSupportersPK string
    RoleGUID                      string
    SpaceID                       string
    UserID                        string
    CreatedAt                     string
    UpdatedAt                     string
}{
    SpacesApplicationSupportersPK: "spaces_application_supporters_pk",
    RoleGUID:                      "role_guid",
    SpaceID:                       "space_id",
    UserID:                        "user_id",
    CreatedAt:                     "created_at",
    UpdatedAt:                     "updated_at",
}

SpacesApplicationSupporterRels is where relationship names are stored.

var SpacesApplicationSupporterRels = struct {
    Space string
    User  string
}{
    Space: "Space",
    User:  "User",
}
var SpacesApplicationSupporterTableColumns = struct {
    SpacesApplicationSupportersPK string
    RoleGUID                      string
    SpaceID                       string
    UserID                        string
    CreatedAt                     string
    UpdatedAt                     string
}{
    SpacesApplicationSupportersPK: "spaces_application_supporters.spaces_application_supporters_pk",
    RoleGUID:                      "spaces_application_supporters.role_guid",
    SpaceID:                       "spaces_application_supporters.space_id",
    UserID:                        "spaces_application_supporters.user_id",
    CreatedAt:                     "spaces_application_supporters.created_at",
    UpdatedAt:                     "spaces_application_supporters.updated_at",
}
var SpacesApplicationSupporterWhere = struct {
    SpacesApplicationSupportersPK whereHelperint
    RoleGUID                      whereHelpernull_String
    SpaceID                       whereHelperint
    UserID                        whereHelperint
    CreatedAt                     whereHelpertime_Time
    UpdatedAt                     whereHelpertime_Time
}{
    SpacesApplicationSupportersPK: whereHelperint{field: "\"spaces_application_supporters\".\"spaces_application_supporters_pk\""},
    RoleGUID:                      whereHelpernull_String{field: "\"spaces_application_supporters\".\"role_guid\""},
    SpaceID:                       whereHelperint{field: "\"spaces_application_supporters\".\"space_id\""},
    UserID:                        whereHelperint{field: "\"spaces_application_supporters\".\"user_id\""},
    CreatedAt:                     whereHelpertime_Time{field: "\"spaces_application_supporters\".\"created_at\""},
    UpdatedAt:                     whereHelpertime_Time{field: "\"spaces_application_supporters\".\"updated_at\""},
}
var SpacesAuditorColumns = struct {
    SpaceID          string
    UserID           string
    SpacesAuditorsPK string
    RoleGUID         string
    CreatedAt        string
    UpdatedAt        string
}{
    SpaceID:          "space_id",
    UserID:           "user_id",
    SpacesAuditorsPK: "spaces_auditors_pk",
    RoleGUID:         "role_guid",
    CreatedAt:        "created_at",
    UpdatedAt:        "updated_at",
}

SpacesAuditorRels is where relationship names are stored.

var SpacesAuditorRels = struct {
    Space string
    User  string
}{
    Space: "Space",
    User:  "User",
}
var SpacesAuditorTableColumns = struct {
    SpaceID          string
    UserID           string
    SpacesAuditorsPK string
    RoleGUID         string
    CreatedAt        string
    UpdatedAt        string
}{
    SpaceID:          "spaces_auditors.space_id",
    UserID:           "spaces_auditors.user_id",
    SpacesAuditorsPK: "spaces_auditors.spaces_auditors_pk",
    RoleGUID:         "spaces_auditors.role_guid",
    CreatedAt:        "spaces_auditors.created_at",
    UpdatedAt:        "spaces_auditors.updated_at",
}
var SpacesAuditorWhere = struct {
    SpaceID          whereHelperint
    UserID           whereHelperint
    SpacesAuditorsPK whereHelperint
    RoleGUID         whereHelpernull_String
    CreatedAt        whereHelpertime_Time
    UpdatedAt        whereHelpertime_Time
}{
    SpaceID:          whereHelperint{field: "\"spaces_auditors\".\"space_id\""},
    UserID:           whereHelperint{field: "\"spaces_auditors\".\"user_id\""},
    SpacesAuditorsPK: whereHelperint{field: "\"spaces_auditors\".\"spaces_auditors_pk\""},
    RoleGUID:         whereHelpernull_String{field: "\"spaces_auditors\".\"role_guid\""},
    CreatedAt:        whereHelpertime_Time{field: "\"spaces_auditors\".\"created_at\""},
    UpdatedAt:        whereHelpertime_Time{field: "\"spaces_auditors\".\"updated_at\""},
}
var SpacesDeveloperColumns = struct {
    SpaceID            string
    UserID             string
    SpacesDevelopersPK string
    RoleGUID           string
    CreatedAt          string
    UpdatedAt          string
}{
    SpaceID:            "space_id",
    UserID:             "user_id",
    SpacesDevelopersPK: "spaces_developers_pk",
    RoleGUID:           "role_guid",
    CreatedAt:          "created_at",
    UpdatedAt:          "updated_at",
}

SpacesDeveloperRels is where relationship names are stored.

var SpacesDeveloperRels = struct {
    Space string
    User  string
}{
    Space: "Space",
    User:  "User",
}
var SpacesDeveloperTableColumns = struct {
    SpaceID            string
    UserID             string
    SpacesDevelopersPK string
    RoleGUID           string
    CreatedAt          string
    UpdatedAt          string
}{
    SpaceID:            "spaces_developers.space_id",
    UserID:             "spaces_developers.user_id",
    SpacesDevelopersPK: "spaces_developers.spaces_developers_pk",
    RoleGUID:           "spaces_developers.role_guid",
    CreatedAt:          "spaces_developers.created_at",
    UpdatedAt:          "spaces_developers.updated_at",
}
var SpacesDeveloperWhere = struct {
    SpaceID            whereHelperint
    UserID             whereHelperint
    SpacesDevelopersPK whereHelperint
    RoleGUID           whereHelpernull_String
    CreatedAt          whereHelpertime_Time
    UpdatedAt          whereHelpertime_Time
}{
    SpaceID:            whereHelperint{field: "\"spaces_developers\".\"space_id\""},
    UserID:             whereHelperint{field: "\"spaces_developers\".\"user_id\""},
    SpacesDevelopersPK: whereHelperint{field: "\"spaces_developers\".\"spaces_developers_pk\""},
    RoleGUID:           whereHelpernull_String{field: "\"spaces_developers\".\"role_guid\""},
    CreatedAt:          whereHelpertime_Time{field: "\"spaces_developers\".\"created_at\""},
    UpdatedAt:          whereHelpertime_Time{field: "\"spaces_developers\".\"updated_at\""},
}
var SpacesManagerColumns = struct {
    SpaceID          string
    UserID           string
    SpacesManagersPK string
    RoleGUID         string
    CreatedAt        string
    UpdatedAt        string
}{
    SpaceID:          "space_id",
    UserID:           "user_id",
    SpacesManagersPK: "spaces_managers_pk",
    RoleGUID:         "role_guid",
    CreatedAt:        "created_at",
    UpdatedAt:        "updated_at",
}

SpacesManagerRels is where relationship names are stored.

var SpacesManagerRels = struct {
    Space string
    User  string
}{
    Space: "Space",
    User:  "User",
}
var SpacesManagerTableColumns = struct {
    SpaceID          string
    UserID           string
    SpacesManagersPK string
    RoleGUID         string
    CreatedAt        string
    UpdatedAt        string
}{
    SpaceID:          "spaces_managers.space_id",
    UserID:           "spaces_managers.user_id",
    SpacesManagersPK: "spaces_managers.spaces_managers_pk",
    RoleGUID:         "spaces_managers.role_guid",
    CreatedAt:        "spaces_managers.created_at",
    UpdatedAt:        "spaces_managers.updated_at",
}
var SpacesManagerWhere = struct {
    SpaceID          whereHelperint
    UserID           whereHelperint
    SpacesManagersPK whereHelperint
    RoleGUID         whereHelpernull_String
    CreatedAt        whereHelpertime_Time
    UpdatedAt        whereHelpertime_Time
}{
    SpaceID:          whereHelperint{field: "\"spaces_managers\".\"space_id\""},
    UserID:           whereHelperint{field: "\"spaces_managers\".\"user_id\""},
    SpacesManagersPK: whereHelperint{field: "\"spaces_managers\".\"spaces_managers_pk\""},
    RoleGUID:         whereHelpernull_String{field: "\"spaces_managers\".\"role_guid\""},
    CreatedAt:        whereHelpertime_Time{field: "\"spaces_managers\".\"created_at\""},
    UpdatedAt:        whereHelpertime_Time{field: "\"spaces_managers\".\"updated_at\""},
}
var StackAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

StackAnnotationRels is where relationship names are stored.

var StackAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var StackAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "stack_annotations.id",
    GUID:         "stack_annotations.guid",
    CreatedAt:    "stack_annotations.created_at",
    UpdatedAt:    "stack_annotations.updated_at",
    ResourceGUID: "stack_annotations.resource_guid",
    KeyPrefix:    "stack_annotations.key_prefix",
    Key:          "stack_annotations.key",
    Value:        "stack_annotations.value",
}
var StackAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"stack_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"stack_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"stack_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"stack_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"stack_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"stack_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"stack_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"stack_annotations\".\"value\""},
}
var StackColumns = struct {
    ID          string
    GUID        string
    CreatedAt   string
    UpdatedAt   string
    Name        string
    Description string
}{
    ID:          "id",
    GUID:        "guid",
    CreatedAt:   "created_at",
    UpdatedAt:   "updated_at",
    Name:        "name",
    Description: "description",
}
var StackLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

StackLabelRels is where relationship names are stored.

var StackLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var StackLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "stack_labels.id",
    GUID:         "stack_labels.guid",
    CreatedAt:    "stack_labels.created_at",
    UpdatedAt:    "stack_labels.updated_at",
    ResourceGUID: "stack_labels.resource_guid",
    KeyPrefix:    "stack_labels.key_prefix",
    KeyName:      "stack_labels.key_name",
    Value:        "stack_labels.value",
}
var StackLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"stack_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"stack_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"stack_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"stack_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"stack_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"stack_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"stack_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"stack_labels\".\"value\""},
}

StackRels is where relationship names are stored.

var StackRels = struct {
    ResourceStackAnnotations string
    ResourceStackLabels      string
}{
    ResourceStackAnnotations: "ResourceStackAnnotations",
    ResourceStackLabels:      "ResourceStackLabels",
}
var StackTableColumns = struct {
    ID          string
    GUID        string
    CreatedAt   string
    UpdatedAt   string
    Name        string
    Description string
}{
    ID:          "stacks.id",
    GUID:        "stacks.guid",
    CreatedAt:   "stacks.created_at",
    UpdatedAt:   "stacks.updated_at",
    Name:        "stacks.name",
    Description: "stacks.description",
}
var StackWhere = struct {
    ID          whereHelperint
    GUID        whereHelperstring
    CreatedAt   whereHelpertime_Time
    UpdatedAt   whereHelpernull_Time
    Name        whereHelperstring
    Description whereHelpernull_String
}{
    ID:          whereHelperint{field: "\"stacks\".\"id\""},
    GUID:        whereHelperstring{field: "\"stacks\".\"guid\""},
    CreatedAt:   whereHelpertime_Time{field: "\"stacks\".\"created_at\""},
    UpdatedAt:   whereHelpernull_Time{field: "\"stacks\".\"updated_at\""},
    Name:        whereHelperstring{field: "\"stacks\".\"name\""},
    Description: whereHelpernull_String{field: "\"stacks\".\"description\""},
}
var StagingSecurityGroupsSpaceColumns = struct {
    StagingSecurityGroupID        string
    StagingSpaceID                string
    StagingSecurityGroupsSpacesPK string
}{
    StagingSecurityGroupID:        "staging_security_group_id",
    StagingSpaceID:                "staging_space_id",
    StagingSecurityGroupsSpacesPK: "staging_security_groups_spaces_pk",
}

StagingSecurityGroupsSpaceRels is where relationship names are stored.

var StagingSecurityGroupsSpaceRels = struct {
    StagingSecurityGroup string
    StagingSpace         string
}{
    StagingSecurityGroup: "StagingSecurityGroup",
    StagingSpace:         "StagingSpace",
}
var StagingSecurityGroupsSpaceTableColumns = struct {
    StagingSecurityGroupID        string
    StagingSpaceID                string
    StagingSecurityGroupsSpacesPK string
}{
    StagingSecurityGroupID:        "staging_security_groups_spaces.staging_security_group_id",
    StagingSpaceID:                "staging_security_groups_spaces.staging_space_id",
    StagingSecurityGroupsSpacesPK: "staging_security_groups_spaces.staging_security_groups_spaces_pk",
}
var StagingSecurityGroupsSpaceWhere = struct {
    StagingSecurityGroupID        whereHelperint
    StagingSpaceID                whereHelperint
    StagingSecurityGroupsSpacesPK whereHelperint
}{
    StagingSecurityGroupID:        whereHelperint{field: "\"staging_security_groups_spaces\".\"staging_security_group_id\""},
    StagingSpaceID:                whereHelperint{field: "\"staging_security_groups_spaces\".\"staging_space_id\""},
    StagingSecurityGroupsSpacesPK: whereHelperint{field: "\"staging_security_groups_spaces\".\"staging_security_groups_spaces_pk\""},
}
var TableNames = struct {
    AppAnnotations                        string
    AppEvents                             string
    AppLabels                             string
    AppUsageEvents                        string
    Apps                                  string
    BuildAnnotations                      string
    BuildLabels                           string
    BuildpackAnnotations                  string
    BuildpackLabels                       string
    BuildpackLifecycleBuildpacks          string
    BuildpackLifecycleData                string
    Buildpacks                            string
    Builds                                string
    ClockJobs                             string
    DelayedJobs                           string
    DeploymentAnnotations                 string
    DeploymentLabels                      string
    DeploymentProcesses                   string
    Deployments                           string
    DomainAnnotations                     string
    DomainLabels                          string
    Domains                               string
    DropletAnnotations                    string
    DropletLabels                         string
    Droplets                              string
    EncryptionKeySentinels                string
    EnvGroups                             string
    Events                                string
    FeatureFlags                          string
    IsolationSegmentAnnotations           string
    IsolationSegmentLabels                string
    IsolationSegments                     string
    JobWarnings                           string
    Jobs                                  string
    KpackLifecycleData                    string
    Lockings                              string
    OrganizationAnnotations               string
    OrganizationLabels                    string
    Organizations                         string
    OrganizationsAuditors                 string
    OrganizationsBillingManagers          string
    OrganizationsIsolationSegments        string
    OrganizationsManagers                 string
    OrganizationsPrivateDomains           string
    OrganizationsUsers                    string
    OrphanedBlobs                         string
    PackageAnnotations                    string
    PackageLabels                         string
    Packages                              string
    ProcessAnnotations                    string
    ProcessLabels                         string
    Processes                             string
    QuotaDefinitions                      string
    RequestCounts                         string
    RevisionAnnotations                   string
    RevisionLabels                        string
    RevisionProcessCommands               string
    RevisionSidecarProcessTypes           string
    RevisionSidecars                      string
    Revisions                             string
    RouteAnnotations                      string
    RouteBindingAnnotations               string
    RouteBindingLabels                    string
    RouteBindingOperations                string
    RouteBindings                         string
    RouteLabels                           string
    RouteMappings                         string
    Routes                                string
    SchemaMigrations                      string
    SecurityGroups                        string
    SecurityGroupsSpaces                  string
    ServiceBindingAnnotations             string
    ServiceBindingLabels                  string
    ServiceBindingOperations              string
    ServiceBindings                       string
    ServiceBrokerAnnotations              string
    ServiceBrokerLabels                   string
    ServiceBrokerUpdateRequestAnnotations string
    ServiceBrokerUpdateRequestLabels      string
    ServiceBrokerUpdateRequests           string
    ServiceBrokers                        string
    ServiceDashboardClients               string
    ServiceInstanceAnnotations            string
    ServiceInstanceLabels                 string
    ServiceInstanceOperations             string
    ServiceInstanceShares                 string
    ServiceInstances                      string
    ServiceKeyAnnotations                 string
    ServiceKeyLabels                      string
    ServiceKeyOperations                  string
    ServiceKeys                           string
    ServiceOfferingAnnotations            string
    ServiceOfferingLabels                 string
    ServicePlanAnnotations                string
    ServicePlanLabels                     string
    ServicePlanVisibilities               string
    ServicePlans                          string
    ServiceUsageEvents                    string
    Services                              string
    SidecarProcessTypes                   string
    Sidecars                              string
    SpaceAnnotations                      string
    SpaceLabels                           string
    SpaceQuotaDefinitions                 string
    Spaces                                string
    SpacesApplicationSupporters           string
    SpacesAuditors                        string
    SpacesDevelopers                      string
    SpacesManagers                        string
    StackAnnotations                      string
    StackLabels                           string
    Stacks                                string
    StagingSecurityGroupsSpaces           string
    TaskAnnotations                       string
    TaskLabels                            string
    Tasks                                 string
    UserAnnotations                       string
    UserLabels                            string
    Users                                 string
}{
    AppAnnotations:                        "app_annotations",
    AppEvents:                             "app_events",
    AppLabels:                             "app_labels",
    AppUsageEvents:                        "app_usage_events",
    Apps:                                  "apps",
    BuildAnnotations:                      "build_annotations",
    BuildLabels:                           "build_labels",
    BuildpackAnnotations:                  "buildpack_annotations",
    BuildpackLabels:                       "buildpack_labels",
    BuildpackLifecycleBuildpacks:          "buildpack_lifecycle_buildpacks",
    BuildpackLifecycleData:                "buildpack_lifecycle_data",
    Buildpacks:                            "buildpacks",
    Builds:                                "builds",
    ClockJobs:                             "clock_jobs",
    DelayedJobs:                           "delayed_jobs",
    DeploymentAnnotations:                 "deployment_annotations",
    DeploymentLabels:                      "deployment_labels",
    DeploymentProcesses:                   "deployment_processes",
    Deployments:                           "deployments",
    DomainAnnotations:                     "domain_annotations",
    DomainLabels:                          "domain_labels",
    Domains:                               "domains",
    DropletAnnotations:                    "droplet_annotations",
    DropletLabels:                         "droplet_labels",
    Droplets:                              "droplets",
    EncryptionKeySentinels:                "encryption_key_sentinels",
    EnvGroups:                             "env_groups",
    Events:                                "events",
    FeatureFlags:                          "feature_flags",
    IsolationSegmentAnnotations:           "isolation_segment_annotations",
    IsolationSegmentLabels:                "isolation_segment_labels",
    IsolationSegments:                     "isolation_segments",
    JobWarnings:                           "job_warnings",
    Jobs:                                  "jobs",
    KpackLifecycleData:                    "kpack_lifecycle_data",
    Lockings:                              "lockings",
    OrganizationAnnotations:               "organization_annotations",
    OrganizationLabels:                    "organization_labels",
    Organizations:                         "organizations",
    OrganizationsAuditors:                 "organizations_auditors",
    OrganizationsBillingManagers:          "organizations_billing_managers",
    OrganizationsIsolationSegments:        "organizations_isolation_segments",
    OrganizationsManagers:                 "organizations_managers",
    OrganizationsPrivateDomains:           "organizations_private_domains",
    OrganizationsUsers:                    "organizations_users",
    OrphanedBlobs:                         "orphaned_blobs",
    PackageAnnotations:                    "package_annotations",
    PackageLabels:                         "package_labels",
    Packages:                              "packages",
    ProcessAnnotations:                    "process_annotations",
    ProcessLabels:                         "process_labels",
    Processes:                             "processes",
    QuotaDefinitions:                      "quota_definitions",
    RequestCounts:                         "request_counts",
    RevisionAnnotations:                   "revision_annotations",
    RevisionLabels:                        "revision_labels",
    RevisionProcessCommands:               "revision_process_commands",
    RevisionSidecarProcessTypes:           "revision_sidecar_process_types",
    RevisionSidecars:                      "revision_sidecars",
    Revisions:                             "revisions",
    RouteAnnotations:                      "route_annotations",
    RouteBindingAnnotations:               "route_binding_annotations",
    RouteBindingLabels:                    "route_binding_labels",
    RouteBindingOperations:                "route_binding_operations",
    RouteBindings:                         "route_bindings",
    RouteLabels:                           "route_labels",
    RouteMappings:                         "route_mappings",
    Routes:                                "routes",
    SchemaMigrations:                      "schema_migrations",
    SecurityGroups:                        "security_groups",
    SecurityGroupsSpaces:                  "security_groups_spaces",
    ServiceBindingAnnotations:             "service_binding_annotations",
    ServiceBindingLabels:                  "service_binding_labels",
    ServiceBindingOperations:              "service_binding_operations",
    ServiceBindings:                       "service_bindings",
    ServiceBrokerAnnotations:              "service_broker_annotations",
    ServiceBrokerLabels:                   "service_broker_labels",
    ServiceBrokerUpdateRequestAnnotations: "service_broker_update_request_annotations",
    ServiceBrokerUpdateRequestLabels:      "service_broker_update_request_labels",
    ServiceBrokerUpdateRequests:           "service_broker_update_requests",
    ServiceBrokers:                        "service_brokers",
    ServiceDashboardClients:               "service_dashboard_clients",
    ServiceInstanceAnnotations:            "service_instance_annotations",
    ServiceInstanceLabels:                 "service_instance_labels",
    ServiceInstanceOperations:             "service_instance_operations",
    ServiceInstanceShares:                 "service_instance_shares",
    ServiceInstances:                      "service_instances",
    ServiceKeyAnnotations:                 "service_key_annotations",
    ServiceKeyLabels:                      "service_key_labels",
    ServiceKeyOperations:                  "service_key_operations",
    ServiceKeys:                           "service_keys",
    ServiceOfferingAnnotations:            "service_offering_annotations",
    ServiceOfferingLabels:                 "service_offering_labels",
    ServicePlanAnnotations:                "service_plan_annotations",
    ServicePlanLabels:                     "service_plan_labels",
    ServicePlanVisibilities:               "service_plan_visibilities",
    ServicePlans:                          "service_plans",
    ServiceUsageEvents:                    "service_usage_events",
    Services:                              "services",
    SidecarProcessTypes:                   "sidecar_process_types",
    Sidecars:                              "sidecars",
    SpaceAnnotations:                      "space_annotations",
    SpaceLabels:                           "space_labels",
    SpaceQuotaDefinitions:                 "space_quota_definitions",
    Spaces:                                "spaces",
    SpacesApplicationSupporters:           "spaces_application_supporters",
    SpacesAuditors:                        "spaces_auditors",
    SpacesDevelopers:                      "spaces_developers",
    SpacesManagers:                        "spaces_managers",
    StackAnnotations:                      "stack_annotations",
    StackLabels:                           "stack_labels",
    Stacks:                                "stacks",
    StagingSecurityGroupsSpaces:           "staging_security_groups_spaces",
    TaskAnnotations:                       "task_annotations",
    TaskLabels:                            "task_labels",
    Tasks:                                 "tasks",
    UserAnnotations:                       "user_annotations",
    UserLabels:                            "user_labels",
    Users:                                 "users",
}
var TaskAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

TaskAnnotationRels is where relationship names are stored.

var TaskAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var TaskAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "task_annotations.id",
    GUID:         "task_annotations.guid",
    CreatedAt:    "task_annotations.created_at",
    UpdatedAt:    "task_annotations.updated_at",
    ResourceGUID: "task_annotations.resource_guid",
    KeyPrefix:    "task_annotations.key_prefix",
    Key:          "task_annotations.key",
    Value:        "task_annotations.value",
}
var TaskAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"task_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"task_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"task_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"task_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"task_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"task_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"task_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"task_annotations\".\"value\""},
}
var TaskColumns = struct {
    ID                            string
    GUID                          string
    CreatedAt                     string
    UpdatedAt                     string
    Name                          string
    Command                       string
    State                         string
    MemoryInMB                    string
    EncryptedEnvironmentVariables string
    Salt                          string
    FailureReason                 string
    AppGUID                       string
    DropletGUID                   string
    SequenceID                    string
    DiskInMB                      string
    EncryptionKeyLabel            string
    EncryptionIterations          string
}{
    ID:                            "id",
    GUID:                          "guid",
    CreatedAt:                     "created_at",
    UpdatedAt:                     "updated_at",
    Name:                          "name",
    Command:                       "command",
    State:                         "state",
    MemoryInMB:                    "memory_in_mb",
    EncryptedEnvironmentVariables: "encrypted_environment_variables",
    Salt:                          "salt",
    FailureReason:                 "failure_reason",
    AppGUID:                       "app_guid",
    DropletGUID:                   "droplet_guid",
    SequenceID:                    "sequence_id",
    DiskInMB:                      "disk_in_mb",
    EncryptionKeyLabel:            "encryption_key_label",
    EncryptionIterations:          "encryption_iterations",
}
var TaskLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

TaskLabelRels is where relationship names are stored.

var TaskLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var TaskLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "task_labels.id",
    GUID:         "task_labels.guid",
    CreatedAt:    "task_labels.created_at",
    UpdatedAt:    "task_labels.updated_at",
    ResourceGUID: "task_labels.resource_guid",
    KeyPrefix:    "task_labels.key_prefix",
    KeyName:      "task_labels.key_name",
    Value:        "task_labels.value",
}
var TaskLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"task_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"task_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"task_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"task_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"task_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"task_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"task_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"task_labels\".\"value\""},
}

TaskRels is where relationship names are stored.

var TaskRels = struct {
    App                     string
    ResourceTaskAnnotations string
    ResourceTaskLabels      string
}{
    App:                     "App",
    ResourceTaskAnnotations: "ResourceTaskAnnotations",
    ResourceTaskLabels:      "ResourceTaskLabels",
}
var TaskTableColumns = struct {
    ID                            string
    GUID                          string
    CreatedAt                     string
    UpdatedAt                     string
    Name                          string
    Command                       string
    State                         string
    MemoryInMB                    string
    EncryptedEnvironmentVariables string
    Salt                          string
    FailureReason                 string
    AppGUID                       string
    DropletGUID                   string
    SequenceID                    string
    DiskInMB                      string
    EncryptionKeyLabel            string
    EncryptionIterations          string
}{
    ID:                            "tasks.id",
    GUID:                          "tasks.guid",
    CreatedAt:                     "tasks.created_at",
    UpdatedAt:                     "tasks.updated_at",
    Name:                          "tasks.name",
    Command:                       "tasks.command",
    State:                         "tasks.state",
    MemoryInMB:                    "tasks.memory_in_mb",
    EncryptedEnvironmentVariables: "tasks.encrypted_environment_variables",
    Salt:                          "tasks.salt",
    FailureReason:                 "tasks.failure_reason",
    AppGUID:                       "tasks.app_guid",
    DropletGUID:                   "tasks.droplet_guid",
    SequenceID:                    "tasks.sequence_id",
    DiskInMB:                      "tasks.disk_in_mb",
    EncryptionKeyLabel:            "tasks.encryption_key_label",
    EncryptionIterations:          "tasks.encryption_iterations",
}
var TaskWhere = struct {
    ID                            whereHelperint
    GUID                          whereHelperstring
    CreatedAt                     whereHelpertime_Time
    UpdatedAt                     whereHelpernull_Time
    Name                          whereHelperstring
    Command                       whereHelperstring
    State                         whereHelperstring
    MemoryInMB                    whereHelpernull_Int
    EncryptedEnvironmentVariables whereHelpernull_String
    Salt                          whereHelpernull_String
    FailureReason                 whereHelpernull_String
    AppGUID                       whereHelperstring
    DropletGUID                   whereHelperstring
    SequenceID                    whereHelpernull_Int
    DiskInMB                      whereHelpernull_Int
    EncryptionKeyLabel            whereHelpernull_String
    EncryptionIterations          whereHelperint
}{
    ID:                            whereHelperint{field: "\"tasks\".\"id\""},
    GUID:                          whereHelperstring{field: "\"tasks\".\"guid\""},
    CreatedAt:                     whereHelpertime_Time{field: "\"tasks\".\"created_at\""},
    UpdatedAt:                     whereHelpernull_Time{field: "\"tasks\".\"updated_at\""},
    Name:                          whereHelperstring{field: "\"tasks\".\"name\""},
    Command:                       whereHelperstring{field: "\"tasks\".\"command\""},
    State:                         whereHelperstring{field: "\"tasks\".\"state\""},
    MemoryInMB:                    whereHelpernull_Int{field: "\"tasks\".\"memory_in_mb\""},
    EncryptedEnvironmentVariables: whereHelpernull_String{field: "\"tasks\".\"encrypted_environment_variables\""},
    Salt:                          whereHelpernull_String{field: "\"tasks\".\"salt\""},
    FailureReason:                 whereHelpernull_String{field: "\"tasks\".\"failure_reason\""},
    AppGUID:                       whereHelperstring{field: "\"tasks\".\"app_guid\""},
    DropletGUID:                   whereHelperstring{field: "\"tasks\".\"droplet_guid\""},
    SequenceID:                    whereHelpernull_Int{field: "\"tasks\".\"sequence_id\""},
    DiskInMB:                      whereHelpernull_Int{field: "\"tasks\".\"disk_in_mb\""},
    EncryptionKeyLabel:            whereHelpernull_String{field: "\"tasks\".\"encryption_key_label\""},
    EncryptionIterations:          whereHelperint{field: "\"tasks\".\"encryption_iterations\""},
}
var UserAnnotationColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    Key:          "key",
    Value:        "value",
}

UserAnnotationRels is where relationship names are stored.

var UserAnnotationRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var UserAnnotationTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    Key          string
    Value        string
}{
    ID:           "user_annotations.id",
    GUID:         "user_annotations.guid",
    CreatedAt:    "user_annotations.created_at",
    UpdatedAt:    "user_annotations.updated_at",
    ResourceGUID: "user_annotations.resource_guid",
    KeyPrefix:    "user_annotations.key_prefix",
    Key:          "user_annotations.key",
    Value:        "user_annotations.value",
}
var UserAnnotationWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    Key          whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"user_annotations\".\"id\""},
    GUID:         whereHelperstring{field: "\"user_annotations\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"user_annotations\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"user_annotations\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"user_annotations\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"user_annotations\".\"key_prefix\""},
    Key:          whereHelpernull_String{field: "\"user_annotations\".\"key\""},
    Value:        whereHelpernull_String{field: "\"user_annotations\".\"value\""},
}
var UserColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    DefaultSpaceID string
    Admin          string
    Active         string
    IsOauthClient  string
}{
    ID:             "id",
    GUID:           "guid",
    CreatedAt:      "created_at",
    UpdatedAt:      "updated_at",
    DefaultSpaceID: "default_space_id",
    Admin:          "admin",
    Active:         "active",
    IsOauthClient:  "is_oauth_client",
}
var UserLabelColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "id",
    GUID:         "guid",
    CreatedAt:    "created_at",
    UpdatedAt:    "updated_at",
    ResourceGUID: "resource_guid",
    KeyPrefix:    "key_prefix",
    KeyName:      "key_name",
    Value:        "value",
}

UserLabelRels is where relationship names are stored.

var UserLabelRels = struct {
    Resource string
}{
    Resource: "Resource",
}
var UserLabelTableColumns = struct {
    ID           string
    GUID         string
    CreatedAt    string
    UpdatedAt    string
    ResourceGUID string
    KeyPrefix    string
    KeyName      string
    Value        string
}{
    ID:           "user_labels.id",
    GUID:         "user_labels.guid",
    CreatedAt:    "user_labels.created_at",
    UpdatedAt:    "user_labels.updated_at",
    ResourceGUID: "user_labels.resource_guid",
    KeyPrefix:    "user_labels.key_prefix",
    KeyName:      "user_labels.key_name",
    Value:        "user_labels.value",
}
var UserLabelWhere = struct {
    ID           whereHelperint
    GUID         whereHelperstring
    CreatedAt    whereHelpertime_Time
    UpdatedAt    whereHelpernull_Time
    ResourceGUID whereHelpernull_String
    KeyPrefix    whereHelpernull_String
    KeyName      whereHelpernull_String
    Value        whereHelpernull_String
}{
    ID:           whereHelperint{field: "\"user_labels\".\"id\""},
    GUID:         whereHelperstring{field: "\"user_labels\".\"guid\""},
    CreatedAt:    whereHelpertime_Time{field: "\"user_labels\".\"created_at\""},
    UpdatedAt:    whereHelpernull_Time{field: "\"user_labels\".\"updated_at\""},
    ResourceGUID: whereHelpernull_String{field: "\"user_labels\".\"resource_guid\""},
    KeyPrefix:    whereHelpernull_String{field: "\"user_labels\".\"key_prefix\""},
    KeyName:      whereHelpernull_String{field: "\"user_labels\".\"key_name\""},
    Value:        whereHelpernull_String{field: "\"user_labels\".\"value\""},
}

UserRels is where relationship names are stored.

var UserRels = struct {
    DefaultSpace                 string
    OrganizationsAuditors        string
    OrganizationsBillingManagers string
    OrganizationsManagers        string
    OrganizationsUsers           string
    SpacesApplicationSupporters  string
    SpacesAuditors               string
    SpacesDevelopers             string
    SpacesManagers               string
    ResourceUserAnnotations      string
    ResourceUserLabels           string
}{
    DefaultSpace:                 "DefaultSpace",
    OrganizationsAuditors:        "OrganizationsAuditors",
    OrganizationsBillingManagers: "OrganizationsBillingManagers",
    OrganizationsManagers:        "OrganizationsManagers",
    OrganizationsUsers:           "OrganizationsUsers",
    SpacesApplicationSupporters:  "SpacesApplicationSupporters",
    SpacesAuditors:               "SpacesAuditors",
    SpacesDevelopers:             "SpacesDevelopers",
    SpacesManagers:               "SpacesManagers",
    ResourceUserAnnotations:      "ResourceUserAnnotations",
    ResourceUserLabels:           "ResourceUserLabels",
}
var UserTableColumns = struct {
    ID             string
    GUID           string
    CreatedAt      string
    UpdatedAt      string
    DefaultSpaceID string
    Admin          string
    Active         string
    IsOauthClient  string
}{
    ID:             "users.id",
    GUID:           "users.guid",
    CreatedAt:      "users.created_at",
    UpdatedAt:      "users.updated_at",
    DefaultSpaceID: "users.default_space_id",
    Admin:          "users.admin",
    Active:         "users.active",
    IsOauthClient:  "users.is_oauth_client",
}
var UserWhere = struct {
    ID             whereHelperint
    GUID           whereHelperstring
    CreatedAt      whereHelpertime_Time
    UpdatedAt      whereHelpernull_Time
    DefaultSpaceID whereHelpernull_Int
    Admin          whereHelpernull_Bool
    Active         whereHelpernull_Bool
    IsOauthClient  whereHelpernull_Bool
}{
    ID:             whereHelperint{field: "\"users\".\"id\""},
    GUID:           whereHelperstring{field: "\"users\".\"guid\""},
    CreatedAt:      whereHelpertime_Time{field: "\"users\".\"created_at\""},
    UpdatedAt:      whereHelpernull_Time{field: "\"users\".\"updated_at\""},
    DefaultSpaceID: whereHelpernull_Int{field: "\"users\".\"default_space_id\""},
    Admin:          whereHelpernull_Bool{field: "\"users\".\"admin\""},
    Active:         whereHelpernull_Bool{field: "\"users\".\"active\""},
    IsOauthClient:  whereHelpernull_Bool{field: "\"users\".\"is_oauth_client\""},
}
var dialect = drivers.Dialect{
    LQ: 0x22,
    RQ: 0x22,

    UseIndexPlaceholders:    true,
    UseLastInsertID:         false,
    UseSchema:               false,
    UseDefaultKeyword:       true,
    UseAutoColumns:          false,
    UseTopClause:            false,
    UseOutputClause:         false,
    UseCaseWhenExistsClause: false,
}
var subqueryDialect = drivers.Dialect{
    LQ: 0x22,
    RQ: 0x22,

    UseIndexPlaceholders:    false,
    UseLastInsertID:         false,
    UseSchema:               false,
    UseDefaultKeyword:       true,
    UseAutoColumns:          false,
    UseTopClause:            false,
    UseOutputClause:         false,
    UseCaseWhenExistsClause: false,
}

func AppAnnotationExists

func AppAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

AppAnnotationExists checks if the AppAnnotation row exists.

func AppEventExists

func AppEventExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

AppEventExists checks if the AppEvent row exists.

func AppExists

func AppExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

AppExists checks if the App row exists.

func AppLabelExists

func AppLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

AppLabelExists checks if the AppLabel row exists.

func AppUsageEventExists

func AppUsageEventExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

AppUsageEventExists checks if the AppUsageEvent row exists.

func BuildAnnotationExists

func BuildAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

BuildAnnotationExists checks if the BuildAnnotation row exists.

func BuildExists

func BuildExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

BuildExists checks if the Build row exists.

func BuildLabelExists

func BuildLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

BuildLabelExists checks if the BuildLabel row exists.

func BuildpackAnnotationExists

func BuildpackAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

BuildpackAnnotationExists checks if the BuildpackAnnotation row exists.

func BuildpackExists

func BuildpackExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

BuildpackExists checks if the Buildpack row exists.

func BuildpackLabelExists

func BuildpackLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

BuildpackLabelExists checks if the BuildpackLabel row exists.

func BuildpackLifecycleBuildpackExists

func BuildpackLifecycleBuildpackExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

BuildpackLifecycleBuildpackExists checks if the BuildpackLifecycleBuildpack row exists.

func BuildpackLifecycleDatumExists

func BuildpackLifecycleDatumExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

BuildpackLifecycleDatumExists checks if the BuildpackLifecycleDatum row exists.

func ClockJobExists

func ClockJobExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ClockJobExists checks if the ClockJob row exists.

func DelayedJobExists

func DelayedJobExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

DelayedJobExists checks if the DelayedJob row exists.

func DeploymentAnnotationExists

func DeploymentAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

DeploymentAnnotationExists checks if the DeploymentAnnotation row exists.

func DeploymentExists

func DeploymentExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

DeploymentExists checks if the Deployment row exists.

func DeploymentLabelExists

func DeploymentLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

DeploymentLabelExists checks if the DeploymentLabel row exists.

func DeploymentProcessExists

func DeploymentProcessExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

DeploymentProcessExists checks if the DeploymentProcess row exists.

func DomainAnnotationExists

func DomainAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

DomainAnnotationExists checks if the DomainAnnotation row exists.

func DomainExists

func DomainExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

DomainExists checks if the Domain row exists.

func DomainLabelExists

func DomainLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

DomainLabelExists checks if the DomainLabel row exists.

func DropletAnnotationExists

func DropletAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

DropletAnnotationExists checks if the DropletAnnotation row exists.

func DropletExists

func DropletExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

DropletExists checks if the Droplet row exists.

func DropletLabelExists

func DropletLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

DropletLabelExists checks if the DropletLabel row exists.

func EncryptionKeySentinelExists

func EncryptionKeySentinelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

EncryptionKeySentinelExists checks if the EncryptionKeySentinel row exists.

func EnvGroupExists

func EnvGroupExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

EnvGroupExists checks if the EnvGroup row exists.

func EventExists

func EventExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

EventExists checks if the Event row exists.

func FeatureFlagExists

func FeatureFlagExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

FeatureFlagExists checks if the FeatureFlag row exists.

func IsolationSegmentAnnotationExists

func IsolationSegmentAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

IsolationSegmentAnnotationExists checks if the IsolationSegmentAnnotation row exists.

func IsolationSegmentExists

func IsolationSegmentExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

IsolationSegmentExists checks if the IsolationSegment row exists.

func IsolationSegmentLabelExists

func IsolationSegmentLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

IsolationSegmentLabelExists checks if the IsolationSegmentLabel row exists.

func JobExists

func JobExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

JobExists checks if the Job row exists.

func JobWarningExists

func JobWarningExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

JobWarningExists checks if the JobWarning row exists.

func KpackLifecycleDatumExists

func KpackLifecycleDatumExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

KpackLifecycleDatumExists checks if the KpackLifecycleDatum row exists.

func LockingExists

func LockingExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

LockingExists checks if the Locking row exists.

func NewQuery

func NewQuery(mods ...qm.QueryMod) *queries.Query

NewQuery initializes a new Query using the passed in QueryMods

func OrganizationAnnotationExists

func OrganizationAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

OrganizationAnnotationExists checks if the OrganizationAnnotation row exists.

func OrganizationExists

func OrganizationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

OrganizationExists checks if the Organization row exists.

func OrganizationLabelExists

func OrganizationLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

OrganizationLabelExists checks if the OrganizationLabel row exists.

func OrganizationsAuditorExists

func OrganizationsAuditorExists(ctx context.Context, exec boil.ContextExecutor, organizationsAuditorsPK int) (bool, error)

OrganizationsAuditorExists checks if the OrganizationsAuditor row exists.

func OrganizationsBillingManagerExists

func OrganizationsBillingManagerExists(ctx context.Context, exec boil.ContextExecutor, organizationsBillingManagersPK int) (bool, error)

OrganizationsBillingManagerExists checks if the OrganizationsBillingManager row exists.

func OrganizationsManagerExists

func OrganizationsManagerExists(ctx context.Context, exec boil.ContextExecutor, organizationsManagersPK int) (bool, error)

OrganizationsManagerExists checks if the OrganizationsManager row exists.

func OrganizationsPrivateDomainExists

func OrganizationsPrivateDomainExists(ctx context.Context, exec boil.ContextExecutor, organizationsPrivateDomainsPK int) (bool, error)

OrganizationsPrivateDomainExists checks if the OrganizationsPrivateDomain row exists.

func OrganizationsUserExists

func OrganizationsUserExists(ctx context.Context, exec boil.ContextExecutor, organizationsUsersPK int) (bool, error)

OrganizationsUserExists checks if the OrganizationsUser row exists.

func OrphanedBlobExists

func OrphanedBlobExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

OrphanedBlobExists checks if the OrphanedBlob row exists.

func PackageAnnotationExists

func PackageAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

PackageAnnotationExists checks if the PackageAnnotation row exists.

func PackageExists

func PackageExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

PackageExists checks if the Package row exists.

func PackageLabelExists

func PackageLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

PackageLabelExists checks if the PackageLabel row exists.

func ProcessAnnotationExists

func ProcessAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ProcessAnnotationExists checks if the ProcessAnnotation row exists.

func ProcessExists

func ProcessExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ProcessExists checks if the Process row exists.

func ProcessLabelExists

func ProcessLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ProcessLabelExists checks if the ProcessLabel row exists.

func QuotaDefinitionExists

func QuotaDefinitionExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

QuotaDefinitionExists checks if the QuotaDefinition row exists.

func Quote

func Quote(in string) string

Quote places dialect specific quotes around a string - useful for building custom SQL

func RequestCountExists

func RequestCountExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RequestCountExists checks if the RequestCount row exists.

func RevisionAnnotationExists

func RevisionAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RevisionAnnotationExists checks if the RevisionAnnotation row exists.

func RevisionExists

func RevisionExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RevisionExists checks if the Revision row exists.

func RevisionLabelExists

func RevisionLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RevisionLabelExists checks if the RevisionLabel row exists.

func RevisionProcessCommandExists

func RevisionProcessCommandExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RevisionProcessCommandExists checks if the RevisionProcessCommand row exists.

func RevisionSidecarExists

func RevisionSidecarExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RevisionSidecarExists checks if the RevisionSidecar row exists.

func RevisionSidecarProcessTypeExists

func RevisionSidecarProcessTypeExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RevisionSidecarProcessTypeExists checks if the RevisionSidecarProcessType row exists.

func RouteAnnotationExists

func RouteAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RouteAnnotationExists checks if the RouteAnnotation row exists.

func RouteBindingAnnotationExists

func RouteBindingAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RouteBindingAnnotationExists checks if the RouteBindingAnnotation row exists.

func RouteBindingExists

func RouteBindingExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RouteBindingExists checks if the RouteBinding row exists.

func RouteBindingLabelExists

func RouteBindingLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RouteBindingLabelExists checks if the RouteBindingLabel row exists.

func RouteBindingOperationExists

func RouteBindingOperationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RouteBindingOperationExists checks if the RouteBindingOperation row exists.

func RouteExists

func RouteExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RouteExists checks if the Route row exists.

func RouteLabelExists

func RouteLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RouteLabelExists checks if the RouteLabel row exists.

func RouteMappingExists

func RouteMappingExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

RouteMappingExists checks if the RouteMapping row exists.

func SchemaMigrationExists

func SchemaMigrationExists(ctx context.Context, exec boil.ContextExecutor, filename string) (bool, error)

SchemaMigrationExists checks if the SchemaMigration row exists.

func SecurityGroupExists

func SecurityGroupExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

SecurityGroupExists checks if the SecurityGroup row exists.

func SecurityGroupsSpaceExists

func SecurityGroupsSpaceExists(ctx context.Context, exec boil.ContextExecutor, securityGroupsSpacesPK int) (bool, error)

SecurityGroupsSpaceExists checks if the SecurityGroupsSpace row exists.

func ServiceBindingAnnotationExists

func ServiceBindingAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceBindingAnnotationExists checks if the ServiceBindingAnnotation row exists.

func ServiceBindingExists

func ServiceBindingExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceBindingExists checks if the ServiceBinding row exists.

func ServiceBindingLabelExists

func ServiceBindingLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceBindingLabelExists checks if the ServiceBindingLabel row exists.

func ServiceBindingOperationExists

func ServiceBindingOperationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceBindingOperationExists checks if the ServiceBindingOperation row exists.

func ServiceBrokerAnnotationExists

func ServiceBrokerAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceBrokerAnnotationExists checks if the ServiceBrokerAnnotation row exists.

func ServiceBrokerExists

func ServiceBrokerExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceBrokerExists checks if the ServiceBroker row exists.

func ServiceBrokerLabelExists

func ServiceBrokerLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceBrokerLabelExists checks if the ServiceBrokerLabel row exists.

func ServiceBrokerUpdateRequestAnnotationExists

func ServiceBrokerUpdateRequestAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceBrokerUpdateRequestAnnotationExists checks if the ServiceBrokerUpdateRequestAnnotation row exists.

func ServiceBrokerUpdateRequestExists

func ServiceBrokerUpdateRequestExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceBrokerUpdateRequestExists checks if the ServiceBrokerUpdateRequest row exists.

func ServiceBrokerUpdateRequestLabelExists

func ServiceBrokerUpdateRequestLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceBrokerUpdateRequestLabelExists checks if the ServiceBrokerUpdateRequestLabel row exists.

func ServiceDashboardClientExists

func ServiceDashboardClientExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceDashboardClientExists checks if the ServiceDashboardClient row exists.

func ServiceExists

func ServiceExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceExists checks if the Service row exists.

func ServiceInstanceAnnotationExists

func ServiceInstanceAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceInstanceAnnotationExists checks if the ServiceInstanceAnnotation row exists.

func ServiceInstanceExists

func ServiceInstanceExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceInstanceExists checks if the ServiceInstance row exists.

func ServiceInstanceLabelExists

func ServiceInstanceLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceInstanceLabelExists checks if the ServiceInstanceLabel row exists.

func ServiceInstanceOperationExists

func ServiceInstanceOperationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceInstanceOperationExists checks if the ServiceInstanceOperation row exists.

func ServiceKeyAnnotationExists

func ServiceKeyAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceKeyAnnotationExists checks if the ServiceKeyAnnotation row exists.

func ServiceKeyExists

func ServiceKeyExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceKeyExists checks if the ServiceKey row exists.

func ServiceKeyLabelExists

func ServiceKeyLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceKeyLabelExists checks if the ServiceKeyLabel row exists.

func ServiceKeyOperationExists

func ServiceKeyOperationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceKeyOperationExists checks if the ServiceKeyOperation row exists.

func ServiceOfferingAnnotationExists

func ServiceOfferingAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceOfferingAnnotationExists checks if the ServiceOfferingAnnotation row exists.

func ServiceOfferingLabelExists

func ServiceOfferingLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceOfferingLabelExists checks if the ServiceOfferingLabel row exists.

func ServicePlanAnnotationExists

func ServicePlanAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServicePlanAnnotationExists checks if the ServicePlanAnnotation row exists.

func ServicePlanExists

func ServicePlanExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServicePlanExists checks if the ServicePlan row exists.

func ServicePlanLabelExists

func ServicePlanLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServicePlanLabelExists checks if the ServicePlanLabel row exists.

func ServicePlanVisibilityExists

func ServicePlanVisibilityExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServicePlanVisibilityExists checks if the ServicePlanVisibility row exists.

func ServiceUsageEventExists

func ServiceUsageEventExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

ServiceUsageEventExists checks if the ServiceUsageEvent row exists.

func SidecarExists

func SidecarExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

SidecarExists checks if the Sidecar row exists.

func SidecarProcessTypeExists

func SidecarProcessTypeExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

SidecarProcessTypeExists checks if the SidecarProcessType row exists.

func SpaceAnnotationExists

func SpaceAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

SpaceAnnotationExists checks if the SpaceAnnotation row exists.

func SpaceExists

func SpaceExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

SpaceExists checks if the Space row exists.

func SpaceLabelExists

func SpaceLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

SpaceLabelExists checks if the SpaceLabel row exists.

func SpaceQuotaDefinitionExists

func SpaceQuotaDefinitionExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

SpaceQuotaDefinitionExists checks if the SpaceQuotaDefinition row exists.

func SpacesApplicationSupporterExists

func SpacesApplicationSupporterExists(ctx context.Context, exec boil.ContextExecutor, spacesApplicationSupportersPK int) (bool, error)

SpacesApplicationSupporterExists checks if the SpacesApplicationSupporter row exists.

func SpacesAuditorExists

func SpacesAuditorExists(ctx context.Context, exec boil.ContextExecutor, spacesAuditorsPK int) (bool, error)

SpacesAuditorExists checks if the SpacesAuditor row exists.

func SpacesDeveloperExists

func SpacesDeveloperExists(ctx context.Context, exec boil.ContextExecutor, spacesDevelopersPK int) (bool, error)

SpacesDeveloperExists checks if the SpacesDeveloper row exists.

func SpacesManagerExists

func SpacesManagerExists(ctx context.Context, exec boil.ContextExecutor, spacesManagersPK int) (bool, error)

SpacesManagerExists checks if the SpacesManager row exists.

func StackAnnotationExists

func StackAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

StackAnnotationExists checks if the StackAnnotation row exists.

func StackExists

func StackExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

StackExists checks if the Stack row exists.

func StackLabelExists

func StackLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

StackLabelExists checks if the StackLabel row exists.

func StagingSecurityGroupsSpaceExists

func StagingSecurityGroupsSpaceExists(ctx context.Context, exec boil.ContextExecutor, stagingSecurityGroupsSpacesPK int) (bool, error)

StagingSecurityGroupsSpaceExists checks if the StagingSecurityGroupsSpace row exists.

func TaskAnnotationExists

func TaskAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

TaskAnnotationExists checks if the TaskAnnotation row exists.

func TaskExists

func TaskExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

TaskExists checks if the Task row exists.

func TaskLabelExists

func TaskLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

TaskLabelExists checks if the TaskLabel row exists.

func UserAnnotationExists

func UserAnnotationExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

UserAnnotationExists checks if the UserAnnotation row exists.

func UserExists

func UserExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

UserExists checks if the User row exists.

func UserLabelExists

func UserLabelExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error)

UserLabelExists checks if the UserLabel row exists.

func buildUpsertQueryPostgres

func buildUpsertQueryPostgres(dia drivers.Dialect, tableName string, updateOnConflict bool, ret, update, conflict, whitelist []string) string

buildUpsertQueryPostgres builds a SQL statement string using the upsertData provided.

func makeCacheKey

func makeCacheKey(cols boil.Columns, nzDefaults []string) string

func removeIsolationSegmentsFromOrganizationsSlice

func removeIsolationSegmentsFromOrganizationsSlice(o *Organization, related []*IsolationSegment)

func removeOrganizationsFromIsolationSegmentsSlice

func removeOrganizationsFromIsolationSegmentsSlice(o *IsolationSegment, related []*Organization)

func removeSharedServiceInstancesFromSpacesSlice

func removeSharedServiceInstancesFromSpacesSlice(o *Space, related []*ServiceInstance)

func removeSpacesFromSharedServiceInstancesSlice

func removeSpacesFromSharedServiceInstancesSlice(o *ServiceInstance, related []*Space)

type App

App is an object representing the database table.

type App struct {
    ID                            int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                          string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt                     time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt                     null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    SpaceGUID                     null.String `boil:"space_guid" json:"space_guid,omitempty" toml:"space_guid" yaml:"space_guid,omitempty"`
    Name                          null.String `boil:"name" json:"name,omitempty" toml:"name" yaml:"name,omitempty"`
    DropletGUID                   null.String `boil:"droplet_guid" json:"droplet_guid,omitempty" toml:"droplet_guid" yaml:"droplet_guid,omitempty"`
    DesiredState                  null.String `boil:"desired_state" json:"desired_state,omitempty" toml:"desired_state" yaml:"desired_state,omitempty"`
    EncryptedEnvironmentVariables null.String `boil:"encrypted_environment_variables" json:"encrypted_environment_variables,omitempty" toml:"encrypted_environment_variables" yaml:"encrypted_environment_variables,omitempty"`
    Salt                          null.String `boil:"salt" json:"salt,omitempty" toml:"salt" yaml:"salt,omitempty"`
    MaxTaskSequenceID             null.Int    `boil:"max_task_sequence_id" json:"max_task_sequence_id,omitempty" toml:"max_task_sequence_id" yaml:"max_task_sequence_id,omitempty"`
    BuildpackCacheSha256Checksum  null.String `boil:"buildpack_cache_sha256_checksum" json:"buildpack_cache_sha256_checksum,omitempty" toml:"buildpack_cache_sha256_checksum" yaml:"buildpack_cache_sha256_checksum,omitempty"`
    EnableSSH                     null.Bool   `boil:"enable_ssh" json:"enable_ssh,omitempty" toml:"enable_ssh" yaml:"enable_ssh,omitempty"`
    EncryptionKeyLabel            null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations          int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`
    RevisionsEnabled              null.Bool   `boil:"revisions_enabled" json:"revisions_enabled,omitempty" toml:"revisions_enabled" yaml:"revisions_enabled,omitempty"`

    R   *appR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   appL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindApp

func FindApp(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*App, error)

FindApp retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type AppAnnotation

AppAnnotation is an object representing the database table.

type AppAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *appAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   appAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindAppAnnotation

func FindAppAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*AppAnnotation, error)

FindAppAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type AppAnnotationDeleter

type AppAnnotationDeleter interface {
    Delete(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o AppAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type AppAnnotationFinder

type AppAnnotationFinder interface {
    FindAppAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*AppAnnotation, error)
}

type AppAnnotationFinisher

type AppAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*AppAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (AppAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type AppAnnotationInserter

type AppAnnotationInserter interface {
    Insert(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type AppAnnotationReloader

type AppAnnotationReloader interface {
    Reload(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *AppAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type AppAnnotationSlice

AppAnnotationSlice is an alias for a slice of pointers to AppAnnotation. This should almost always be used instead of []AppAnnotation.

type AppAnnotationSlice []*AppAnnotation

type AppAnnotationUpdater

type AppAnnotationUpdater interface {
    Update(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o AppAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type AppAnnotationUpserter

type AppAnnotationUpserter interface {
    Upsert(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type AppDeleter

type AppDeleter interface {
    Delete(o *App, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o AppSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type AppEvent

AppEvent is an object representing the database table.

type AppEvent struct {
    ID              int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID            string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt       time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt       null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    AppID           int         `boil:"app_id" json:"app_id" toml:"app_id" yaml:"app_id"`
    InstanceGUID    string      `boil:"instance_guid" json:"instance_guid" toml:"instance_guid" yaml:"instance_guid"`
    InstanceIndex   int         `boil:"instance_index" json:"instance_index" toml:"instance_index" yaml:"instance_index"`
    ExitStatus      int         `boil:"exit_status" json:"exit_status" toml:"exit_status" yaml:"exit_status"`
    Timestamp       time.Time   `boil:"timestamp" json:"timestamp" toml:"timestamp" yaml:"timestamp"`
    ExitDescription null.String `boil:"exit_description" json:"exit_description,omitempty" toml:"exit_description" yaml:"exit_description,omitempty"`

    R   *appEventR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   appEventL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindAppEvent

func FindAppEvent(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*AppEvent, error)

FindAppEvent retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type AppEventDeleter

type AppEventDeleter interface {
    Delete(o *AppEvent, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o AppEventSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type AppEventFinder

type AppEventFinder interface {
    FindAppEvent(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*AppEvent, error)
}

type AppEventFinisher

type AppEventFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*AppEvent, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (AppEventSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type AppEventInserter

type AppEventInserter interface {
    Insert(o *AppEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type AppEventReloader

type AppEventReloader interface {
    Reload(o *AppEvent, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *AppEventSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type AppEventSlice

AppEventSlice is an alias for a slice of pointers to AppEvent. This should almost always be used instead of []AppEvent.

type AppEventSlice []*AppEvent

type AppEventUpdater

type AppEventUpdater interface {
    Update(o *AppEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o AppEventSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type AppEventUpserter

type AppEventUpserter interface {
    Upsert(o *AppEvent, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type AppFinder

type AppFinder interface {
    FindApp(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*App, error)
}

type AppFinisher

type AppFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*App, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (AppSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type AppInserter

type AppInserter interface {
    Insert(o *App, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type AppLabel

AppLabel is an object representing the database table.

type AppLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *appLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   appLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindAppLabel

func FindAppLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*AppLabel, error)

FindAppLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type AppLabelDeleter

type AppLabelDeleter interface {
    Delete(o *AppLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o AppLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type AppLabelFinder

type AppLabelFinder interface {
    FindAppLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*AppLabel, error)
}

type AppLabelFinisher

type AppLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*AppLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (AppLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type AppLabelInserter

type AppLabelInserter interface {
    Insert(o *AppLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type AppLabelReloader

type AppLabelReloader interface {
    Reload(o *AppLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *AppLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type AppLabelSlice

AppLabelSlice is an alias for a slice of pointers to AppLabel. This should almost always be used instead of []AppLabel.

type AppLabelSlice []*AppLabel

type AppLabelUpdater

type AppLabelUpdater interface {
    Update(o *AppLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o AppLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type AppLabelUpserter

type AppLabelUpserter interface {
    Upsert(o *AppLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type AppReloader

type AppReloader interface {
    Reload(o *App, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *AppSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type AppSlice

AppSlice is an alias for a slice of pointers to App. This should almost always be used instead of []App.

type AppSlice []*App

type AppUpdater

type AppUpdater interface {
    Update(o *App, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o AppSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type AppUpserter

type AppUpserter interface {
    Upsert(o *App, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type AppUsageEvent

AppUsageEvent is an object representing the database table.

type AppUsageEvent struct {
    ID                            int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                          string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt                     time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    InstanceCount                 int         `boil:"instance_count" json:"instance_count" toml:"instance_count" yaml:"instance_count"`
    MemoryInMBPerInstance         int         `boil:"memory_in_mb_per_instance" json:"memory_in_mb_per_instance" toml:"memory_in_mb_per_instance" yaml:"memory_in_mb_per_instance"`
    State                         string      `boil:"state" json:"state" toml:"state" yaml:"state"`
    AppGUID                       string      `boil:"app_guid" json:"app_guid" toml:"app_guid" yaml:"app_guid"`
    AppName                       string      `boil:"app_name" json:"app_name" toml:"app_name" yaml:"app_name"`
    SpaceGUID                     string      `boil:"space_guid" json:"space_guid" toml:"space_guid" yaml:"space_guid"`
    SpaceName                     string      `boil:"space_name" json:"space_name" toml:"space_name" yaml:"space_name"`
    OrgGUID                       string      `boil:"org_guid" json:"org_guid" toml:"org_guid" yaml:"org_guid"`
    BuildpackGUID                 null.String `boil:"buildpack_guid" json:"buildpack_guid,omitempty" toml:"buildpack_guid" yaml:"buildpack_guid,omitempty"`
    BuildpackName                 null.String `boil:"buildpack_name" json:"buildpack_name,omitempty" toml:"buildpack_name" yaml:"buildpack_name,omitempty"`
    PackageState                  null.String `boil:"package_state" json:"package_state,omitempty" toml:"package_state" yaml:"package_state,omitempty"`
    ParentAppName                 null.String `boil:"parent_app_name" json:"parent_app_name,omitempty" toml:"parent_app_name" yaml:"parent_app_name,omitempty"`
    ParentAppGUID                 null.String `boil:"parent_app_guid" json:"parent_app_guid,omitempty" toml:"parent_app_guid" yaml:"parent_app_guid,omitempty"`
    ProcessType                   null.String `boil:"process_type" json:"process_type,omitempty" toml:"process_type" yaml:"process_type,omitempty"`
    TaskGUID                      null.String `boil:"task_guid" json:"task_guid,omitempty" toml:"task_guid" yaml:"task_guid,omitempty"`
    TaskName                      null.String `boil:"task_name" json:"task_name,omitempty" toml:"task_name" yaml:"task_name,omitempty"`
    PackageGUID                   null.String `boil:"package_guid" json:"package_guid,omitempty" toml:"package_guid" yaml:"package_guid,omitempty"`
    PreviousState                 null.String `boil:"previous_state" json:"previous_state,omitempty" toml:"previous_state" yaml:"previous_state,omitempty"`
    PreviousPackageState          null.String `boil:"previous_package_state" json:"previous_package_state,omitempty" toml:"previous_package_state" yaml:"previous_package_state,omitempty"`
    PreviousMemoryInMBPerInstance null.Int    `boil:"previous_memory_in_mb_per_instance" json:"previous_memory_in_mb_per_instance,omitempty" toml:"previous_memory_in_mb_per_instance" yaml:"previous_memory_in_mb_per_instance,omitempty"`
    PreviousInstanceCount         null.Int    `boil:"previous_instance_count" json:"previous_instance_count,omitempty" toml:"previous_instance_count" yaml:"previous_instance_count,omitempty"`

    R   *appUsageEventR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   appUsageEventL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindAppUsageEvent

func FindAppUsageEvent(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*AppUsageEvent, error)

FindAppUsageEvent retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type AppUsageEventDeleter

type AppUsageEventDeleter interface {
    Delete(o *AppUsageEvent, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o AppUsageEventSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type AppUsageEventFinder

type AppUsageEventFinder interface {
    FindAppUsageEvent(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*AppUsageEvent, error)
}

type AppUsageEventFinisher

type AppUsageEventFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*AppUsageEvent, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (AppUsageEventSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type AppUsageEventInserter

type AppUsageEventInserter interface {
    Insert(o *AppUsageEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type AppUsageEventReloader

type AppUsageEventReloader interface {
    Reload(o *AppUsageEvent, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *AppUsageEventSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type AppUsageEventSlice

AppUsageEventSlice is an alias for a slice of pointers to AppUsageEvent. This should almost always be used instead of []AppUsageEvent.

type AppUsageEventSlice []*AppUsageEvent

type AppUsageEventUpdater

type AppUsageEventUpdater interface {
    Update(o *AppUsageEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o AppUsageEventSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type AppUsageEventUpserter

type AppUsageEventUpserter interface {
    Upsert(o *AppUsageEvent, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Build

Build is an object representing the database table.

type Build struct {
    ID                 int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID               string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt          time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt          null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    State              null.String `boil:"state" json:"state,omitempty" toml:"state" yaml:"state,omitempty"`
    PackageGUID        null.String `boil:"package_guid" json:"package_guid,omitempty" toml:"package_guid" yaml:"package_guid,omitempty"`
    ErrorDescription   null.String `boil:"error_description" json:"error_description,omitempty" toml:"error_description" yaml:"error_description,omitempty"`
    AppGUID            null.String `boil:"app_guid" json:"app_guid,omitempty" toml:"app_guid" yaml:"app_guid,omitempty"`
    ErrorID            null.String `boil:"error_id" json:"error_id,omitempty" toml:"error_id" yaml:"error_id,omitempty"`
    CreatedByUserGUID  null.String `boil:"created_by_user_guid" json:"created_by_user_guid,omitempty" toml:"created_by_user_guid" yaml:"created_by_user_guid,omitempty"`
    CreatedByUserName  null.String `boil:"created_by_user_name" json:"created_by_user_name,omitempty" toml:"created_by_user_name" yaml:"created_by_user_name,omitempty"`
    CreatedByUserEmail null.String `boil:"created_by_user_email" json:"created_by_user_email,omitempty" toml:"created_by_user_email" yaml:"created_by_user_email,omitempty"`
    StagingMemoryInMB  null.Int    `boil:"staging_memory_in_mb" json:"staging_memory_in_mb,omitempty" toml:"staging_memory_in_mb" yaml:"staging_memory_in_mb,omitempty"`
    StagingDiskInMB    null.Int    `boil:"staging_disk_in_mb" json:"staging_disk_in_mb,omitempty" toml:"staging_disk_in_mb" yaml:"staging_disk_in_mb,omitempty"`

    R   *buildR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   buildL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindBuild

func FindBuild(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Build, error)

FindBuild retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type BuildAnnotation

BuildAnnotation is an object representing the database table.

type BuildAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *buildAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   buildAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindBuildAnnotation

func FindBuildAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildAnnotation, error)

FindBuildAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type BuildAnnotationDeleter

type BuildAnnotationDeleter interface {
    Delete(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o BuildAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type BuildAnnotationFinder

type BuildAnnotationFinder interface {
    FindBuildAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildAnnotation, error)
}

type BuildAnnotationFinisher

type BuildAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*BuildAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (BuildAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type BuildAnnotationInserter

type BuildAnnotationInserter interface {
    Insert(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type BuildAnnotationReloader

type BuildAnnotationReloader interface {
    Reload(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *BuildAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type BuildAnnotationSlice

BuildAnnotationSlice is an alias for a slice of pointers to BuildAnnotation. This should almost always be used instead of []BuildAnnotation.

type BuildAnnotationSlice []*BuildAnnotation

type BuildAnnotationUpdater

type BuildAnnotationUpdater interface {
    Update(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o BuildAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type BuildAnnotationUpserter

type BuildAnnotationUpserter interface {
    Upsert(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type BuildDeleter

type BuildDeleter interface {
    Delete(o *Build, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o BuildSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type BuildFinder

type BuildFinder interface {
    FindBuild(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Build, error)
}

type BuildFinisher

type BuildFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Build, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (BuildSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type BuildInserter

type BuildInserter interface {
    Insert(o *Build, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type BuildLabel

BuildLabel is an object representing the database table.

type BuildLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *buildLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   buildLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindBuildLabel

func FindBuildLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildLabel, error)

FindBuildLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type BuildLabelDeleter

type BuildLabelDeleter interface {
    Delete(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o BuildLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type BuildLabelFinder

type BuildLabelFinder interface {
    FindBuildLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildLabel, error)
}

type BuildLabelFinisher

type BuildLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*BuildLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (BuildLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type BuildLabelInserter

type BuildLabelInserter interface {
    Insert(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type BuildLabelReloader

type BuildLabelReloader interface {
    Reload(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *BuildLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type BuildLabelSlice

BuildLabelSlice is an alias for a slice of pointers to BuildLabel. This should almost always be used instead of []BuildLabel.

type BuildLabelSlice []*BuildLabel

type BuildLabelUpdater

type BuildLabelUpdater interface {
    Update(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o BuildLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type BuildLabelUpserter

type BuildLabelUpserter interface {
    Upsert(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type BuildReloader

type BuildReloader interface {
    Reload(o *Build, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *BuildSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type BuildSlice

BuildSlice is an alias for a slice of pointers to Build. This should almost always be used instead of []Build.

type BuildSlice []*Build

type BuildUpdater

type BuildUpdater interface {
    Update(o *Build, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o BuildSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type BuildUpserter

type BuildUpserter interface {
    Upsert(o *Build, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Buildpack

Buildpack is an object representing the database table.

type Buildpack struct {
    ID             int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID           string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt      time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt      null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name           string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    Key            null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Position       int         `boil:"position" json:"position" toml:"position" yaml:"position"`
    Enabled        null.Bool   `boil:"enabled" json:"enabled,omitempty" toml:"enabled" yaml:"enabled,omitempty"`
    Locked         null.Bool   `boil:"locked" json:"locked,omitempty" toml:"locked" yaml:"locked,omitempty"`
    Filename       null.String `boil:"filename" json:"filename,omitempty" toml:"filename" yaml:"filename,omitempty"`
    Sha256Checksum null.String `boil:"sha256_checksum" json:"sha256_checksum,omitempty" toml:"sha256_checksum" yaml:"sha256_checksum,omitempty"`
    Stack          null.String `boil:"stack" json:"stack,omitempty" toml:"stack" yaml:"stack,omitempty"`

    R   *buildpackR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   buildpackL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindBuildpack

func FindBuildpack(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Buildpack, error)

FindBuildpack retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type BuildpackAnnotation

BuildpackAnnotation is an object representing the database table.

type BuildpackAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *buildpackAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   buildpackAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindBuildpackAnnotation

func FindBuildpackAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildpackAnnotation, error)

FindBuildpackAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type BuildpackAnnotationDeleter

type BuildpackAnnotationDeleter interface {
    Delete(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o BuildpackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type BuildpackAnnotationFinder

type BuildpackAnnotationFinder interface {
    FindBuildpackAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildpackAnnotation, error)
}

type BuildpackAnnotationFinisher

type BuildpackAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*BuildpackAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (BuildpackAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type BuildpackAnnotationInserter

type BuildpackAnnotationInserter interface {
    Insert(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type BuildpackAnnotationReloader

type BuildpackAnnotationReloader interface {
    Reload(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *BuildpackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type BuildpackAnnotationSlice

BuildpackAnnotationSlice is an alias for a slice of pointers to BuildpackAnnotation. This should almost always be used instead of []BuildpackAnnotation.

type BuildpackAnnotationSlice []*BuildpackAnnotation

type BuildpackAnnotationUpdater

type BuildpackAnnotationUpdater interface {
    Update(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o BuildpackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type BuildpackAnnotationUpserter

type BuildpackAnnotationUpserter interface {
    Upsert(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type BuildpackDeleter

type BuildpackDeleter interface {
    Delete(o *Buildpack, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o BuildpackSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type BuildpackFinder

type BuildpackFinder interface {
    FindBuildpack(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Buildpack, error)
}

type BuildpackFinisher

type BuildpackFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Buildpack, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (BuildpackSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type BuildpackInserter

type BuildpackInserter interface {
    Insert(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type BuildpackLabel

BuildpackLabel is an object representing the database table.

type BuildpackLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *buildpackLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   buildpackLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindBuildpackLabel

func FindBuildpackLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildpackLabel, error)

FindBuildpackLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type BuildpackLabelDeleter

type BuildpackLabelDeleter interface {
    Delete(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o BuildpackLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type BuildpackLabelFinder

type BuildpackLabelFinder interface {
    FindBuildpackLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildpackLabel, error)
}

type BuildpackLabelFinisher

type BuildpackLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*BuildpackLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (BuildpackLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type BuildpackLabelInserter

type BuildpackLabelInserter interface {
    Insert(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type BuildpackLabelReloader

type BuildpackLabelReloader interface {
    Reload(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *BuildpackLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type BuildpackLabelSlice

BuildpackLabelSlice is an alias for a slice of pointers to BuildpackLabel. This should almost always be used instead of []BuildpackLabel.

type BuildpackLabelSlice []*BuildpackLabel

type BuildpackLabelUpdater

type BuildpackLabelUpdater interface {
    Update(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o BuildpackLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type BuildpackLabelUpserter

type BuildpackLabelUpserter interface {
    Upsert(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type BuildpackLifecycleBuildpack

BuildpackLifecycleBuildpack is an object representing the database table.

type BuildpackLifecycleBuildpack struct {
    ID                         int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                       string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt                  time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt                  null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    AdminBuildpackName         null.String `boil:"admin_buildpack_name" json:"admin_buildpack_name,omitempty" toml:"admin_buildpack_name" yaml:"admin_buildpack_name,omitempty"`
    EncryptedBuildpackURL      null.String `boil:"encrypted_buildpack_url" json:"encrypted_buildpack_url,omitempty" toml:"encrypted_buildpack_url" yaml:"encrypted_buildpack_url,omitempty"`
    EncryptedBuildpackURLSalt  null.String `boil:"encrypted_buildpack_url_salt" json:"encrypted_buildpack_url_salt,omitempty" toml:"encrypted_buildpack_url_salt" yaml:"encrypted_buildpack_url_salt,omitempty"`
    BuildpackLifecycleDataGUID null.String `boil:"buildpack_lifecycle_data_guid" json:"buildpack_lifecycle_data_guid,omitempty" toml:"buildpack_lifecycle_data_guid" yaml:"buildpack_lifecycle_data_guid,omitempty"`
    EncryptionKeyLabel         null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    Version                    null.String `boil:"version" json:"version,omitempty" toml:"version" yaml:"version,omitempty"`
    BuildpackName              null.String `boil:"buildpack_name" json:"buildpack_name,omitempty" toml:"buildpack_name" yaml:"buildpack_name,omitempty"`
    EncryptionIterations       int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`

    R   *buildpackLifecycleBuildpackR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   buildpackLifecycleBuildpackL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindBuildpackLifecycleBuildpack

func FindBuildpackLifecycleBuildpack(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildpackLifecycleBuildpack, error)

FindBuildpackLifecycleBuildpack retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type BuildpackLifecycleBuildpackDeleter

type BuildpackLifecycleBuildpackDeleter interface {
    Delete(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o BuildpackLifecycleBuildpackSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type BuildpackLifecycleBuildpackFinder

type BuildpackLifecycleBuildpackFinder interface {
    FindBuildpackLifecycleBuildpack(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildpackLifecycleBuildpack, error)
}

type BuildpackLifecycleBuildpackFinisher

type BuildpackLifecycleBuildpackFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*BuildpackLifecycleBuildpack, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (BuildpackLifecycleBuildpackSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type BuildpackLifecycleBuildpackInserter

type BuildpackLifecycleBuildpackInserter interface {
    Insert(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type BuildpackLifecycleBuildpackReloader

type BuildpackLifecycleBuildpackReloader interface {
    Reload(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *BuildpackLifecycleBuildpackSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type BuildpackLifecycleBuildpackSlice

BuildpackLifecycleBuildpackSlice is an alias for a slice of pointers to BuildpackLifecycleBuildpack. This should almost always be used instead of []BuildpackLifecycleBuildpack.

type BuildpackLifecycleBuildpackSlice []*BuildpackLifecycleBuildpack

type BuildpackLifecycleBuildpackUpdater

type BuildpackLifecycleBuildpackUpdater interface {
    Update(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o BuildpackLifecycleBuildpackSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type BuildpackLifecycleBuildpackUpserter

type BuildpackLifecycleBuildpackUpserter interface {
    Upsert(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type BuildpackLifecycleDatum

BuildpackLifecycleDatum is an object representing the database table.

type BuildpackLifecycleDatum struct {
    ID                        int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                      string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt                 time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt                 null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    AppGUID                   null.String `boil:"app_guid" json:"app_guid,omitempty" toml:"app_guid" yaml:"app_guid,omitempty"`
    DropletGUID               null.String `boil:"droplet_guid" json:"droplet_guid,omitempty" toml:"droplet_guid" yaml:"droplet_guid,omitempty"`
    Stack                     null.String `boil:"stack" json:"stack,omitempty" toml:"stack" yaml:"stack,omitempty"`
    EncryptedBuildpackURL     null.String `boil:"encrypted_buildpack_url" json:"encrypted_buildpack_url,omitempty" toml:"encrypted_buildpack_url" yaml:"encrypted_buildpack_url,omitempty"`
    EncryptedBuildpackURLSalt null.String `boil:"encrypted_buildpack_url_salt" json:"encrypted_buildpack_url_salt,omitempty" toml:"encrypted_buildpack_url_salt" yaml:"encrypted_buildpack_url_salt,omitempty"`
    AdminBuildpackName        null.String `boil:"admin_buildpack_name" json:"admin_buildpack_name,omitempty" toml:"admin_buildpack_name" yaml:"admin_buildpack_name,omitempty"`
    BuildGUID                 null.String `boil:"build_guid" json:"build_guid,omitempty" toml:"build_guid" yaml:"build_guid,omitempty"`
    EncryptionKeyLabel        null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations      int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`

    R   *buildpackLifecycleDatumR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   buildpackLifecycleDatumL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindBuildpackLifecycleDatum

func FindBuildpackLifecycleDatum(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildpackLifecycleDatum, error)

FindBuildpackLifecycleDatum retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type BuildpackLifecycleDatumDeleter

type BuildpackLifecycleDatumDeleter interface {
    Delete(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o BuildpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type BuildpackLifecycleDatumFinder

type BuildpackLifecycleDatumFinder interface {
    FindBuildpackLifecycleDatum(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*BuildpackLifecycleDatum, error)
}

type BuildpackLifecycleDatumFinisher

type BuildpackLifecycleDatumFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*BuildpackLifecycleDatum, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (BuildpackLifecycleDatumSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type BuildpackLifecycleDatumInserter

type BuildpackLifecycleDatumInserter interface {
    Insert(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type BuildpackLifecycleDatumReloader

type BuildpackLifecycleDatumReloader interface {
    Reload(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *BuildpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type BuildpackLifecycleDatumSlice

BuildpackLifecycleDatumSlice is an alias for a slice of pointers to BuildpackLifecycleDatum. This should almost always be used instead of []BuildpackLifecycleDatum.

type BuildpackLifecycleDatumSlice []*BuildpackLifecycleDatum

type BuildpackLifecycleDatumUpdater

type BuildpackLifecycleDatumUpdater interface {
    Update(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o BuildpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type BuildpackLifecycleDatumUpserter

type BuildpackLifecycleDatumUpserter interface {
    Upsert(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type BuildpackReloader

type BuildpackReloader interface {
    Reload(o *Buildpack, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *BuildpackSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type BuildpackSlice

BuildpackSlice is an alias for a slice of pointers to Buildpack. This should almost always be used instead of []Buildpack.

type BuildpackSlice []*Buildpack

type BuildpackUpdater

type BuildpackUpdater interface {
    Update(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o BuildpackSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type BuildpackUpserter

type BuildpackUpserter interface {
    Upsert(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ClockJob

ClockJob is an object representing the database table.

type ClockJob struct {
    ID              int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    Name            string    `boil:"name" json:"name" toml:"name" yaml:"name"`
    LastStartedAt   null.Time `boil:"last_started_at" json:"last_started_at,omitempty" toml:"last_started_at" yaml:"last_started_at,omitempty"`
    LastCompletedAt null.Time `boil:"last_completed_at" json:"last_completed_at,omitempty" toml:"last_completed_at" yaml:"last_completed_at,omitempty"`

    R   *clockJobR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   clockJobL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindClockJob

func FindClockJob(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ClockJob, error)

FindClockJob retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ClockJobDeleter

type ClockJobDeleter interface {
    Delete(o *ClockJob, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ClockJobSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ClockJobFinder

type ClockJobFinder interface {
    FindClockJob(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ClockJob, error)
}

type ClockJobFinisher

type ClockJobFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ClockJob, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ClockJobSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ClockJobInserter

type ClockJobInserter interface {
    Insert(o *ClockJob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ClockJobReloader

type ClockJobReloader interface {
    Reload(o *ClockJob, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ClockJobSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ClockJobSlice

ClockJobSlice is an alias for a slice of pointers to ClockJob. This should almost always be used instead of []ClockJob.

type ClockJobSlice []*ClockJob

type ClockJobUpdater

type ClockJobUpdater interface {
    Update(o *ClockJob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ClockJobSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ClockJobUpserter

type ClockJobUpserter interface {
    Upsert(o *ClockJob, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type DelayedJob

DelayedJob is an object representing the database table.

type DelayedJob struct {
    ID         int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID       string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt  time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt  null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Priority   null.Int    `boil:"priority" json:"priority,omitempty" toml:"priority" yaml:"priority,omitempty"`
    Attempts   null.Int    `boil:"attempts" json:"attempts,omitempty" toml:"attempts" yaml:"attempts,omitempty"`
    Handler    null.String `boil:"handler" json:"handler,omitempty" toml:"handler" yaml:"handler,omitempty"`
    LastError  null.String `boil:"last_error" json:"last_error,omitempty" toml:"last_error" yaml:"last_error,omitempty"`
    RunAt      null.Time   `boil:"run_at" json:"run_at,omitempty" toml:"run_at" yaml:"run_at,omitempty"`
    LockedAt   null.Time   `boil:"locked_at" json:"locked_at,omitempty" toml:"locked_at" yaml:"locked_at,omitempty"`
    FailedAt   null.Time   `boil:"failed_at" json:"failed_at,omitempty" toml:"failed_at" yaml:"failed_at,omitempty"`
    LockedBy   null.String `boil:"locked_by" json:"locked_by,omitempty" toml:"locked_by" yaml:"locked_by,omitempty"`
    Queue      null.String `boil:"queue" json:"queue,omitempty" toml:"queue" yaml:"queue,omitempty"`
    CFAPIError null.String `boil:"cf_api_error" json:"cf_api_error,omitempty" toml:"cf_api_error" yaml:"cf_api_error,omitempty"`

    R   *delayedJobR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   delayedJobL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindDelayedJob

func FindDelayedJob(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DelayedJob, error)

FindDelayedJob retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type DelayedJobDeleter

type DelayedJobDeleter interface {
    Delete(o *DelayedJob, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o DelayedJobSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type DelayedJobFinder

type DelayedJobFinder interface {
    FindDelayedJob(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DelayedJob, error)
}

type DelayedJobFinisher

type DelayedJobFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*DelayedJob, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (DelayedJobSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type DelayedJobInserter

type DelayedJobInserter interface {
    Insert(o *DelayedJob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type DelayedJobReloader

type DelayedJobReloader interface {
    Reload(o *DelayedJob, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *DelayedJobSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type DelayedJobSlice

DelayedJobSlice is an alias for a slice of pointers to DelayedJob. This should almost always be used instead of []DelayedJob.

type DelayedJobSlice []*DelayedJob

type DelayedJobUpdater

type DelayedJobUpdater interface {
    Update(o *DelayedJob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o DelayedJobSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type DelayedJobUpserter

type DelayedJobUpserter interface {
    Upsert(o *DelayedJob, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Deployment

Deployment is an object representing the database table.

type Deployment struct {
    ID                              int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                            string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt                       time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt                       null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    State                           null.String `boil:"state" json:"state,omitempty" toml:"state" yaml:"state,omitempty"`
    AppGUID                         null.String `boil:"app_guid" json:"app_guid,omitempty" toml:"app_guid" yaml:"app_guid,omitempty"`
    DropletGUID                     null.String `boil:"droplet_guid" json:"droplet_guid,omitempty" toml:"droplet_guid" yaml:"droplet_guid,omitempty"`
    DeployingWebProcessGUID         null.String `boil:"deploying_web_process_guid" json:"deploying_web_process_guid,omitempty" toml:"deploying_web_process_guid" yaml:"deploying_web_process_guid,omitempty"`
    PreviousDropletGUID             null.String `boil:"previous_droplet_guid" json:"previous_droplet_guid,omitempty" toml:"previous_droplet_guid" yaml:"previous_droplet_guid,omitempty"`
    OriginalWebProcessInstanceCount int         `boil:"original_web_process_instance_count" json:"original_web_process_instance_count" toml:"original_web_process_instance_count" yaml:"original_web_process_instance_count"`
    RevisionGUID                    null.String `boil:"revision_guid" json:"revision_guid,omitempty" toml:"revision_guid" yaml:"revision_guid,omitempty"`
    RevisionVersion                 null.Int    `boil:"revision_version" json:"revision_version,omitempty" toml:"revision_version" yaml:"revision_version,omitempty"`
    LastHealthyAt                   time.Time   `boil:"last_healthy_at" json:"last_healthy_at" toml:"last_healthy_at" yaml:"last_healthy_at"`
    StatusValue                     null.String `boil:"status_value" json:"status_value,omitempty" toml:"status_value" yaml:"status_value,omitempty"`
    StatusReason                    null.String `boil:"status_reason" json:"status_reason,omitempty" toml:"status_reason" yaml:"status_reason,omitempty"`
    Strategy                        string      `boil:"strategy" json:"strategy" toml:"strategy" yaml:"strategy"`

    R   *deploymentR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   deploymentL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindDeployment

func FindDeployment(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Deployment, error)

FindDeployment retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type DeploymentAnnotation

DeploymentAnnotation is an object representing the database table.

type DeploymentAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *deploymentAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   deploymentAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindDeploymentAnnotation

func FindDeploymentAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DeploymentAnnotation, error)

FindDeploymentAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type DeploymentAnnotationDeleter

type DeploymentAnnotationDeleter interface {
    Delete(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o DeploymentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type DeploymentAnnotationFinder

type DeploymentAnnotationFinder interface {
    FindDeploymentAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DeploymentAnnotation, error)
}

type DeploymentAnnotationFinisher

type DeploymentAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*DeploymentAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (DeploymentAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type DeploymentAnnotationInserter

type DeploymentAnnotationInserter interface {
    Insert(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type DeploymentAnnotationReloader

type DeploymentAnnotationReloader interface {
    Reload(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *DeploymentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type DeploymentAnnotationSlice

DeploymentAnnotationSlice is an alias for a slice of pointers to DeploymentAnnotation. This should almost always be used instead of []DeploymentAnnotation.

type DeploymentAnnotationSlice []*DeploymentAnnotation

type DeploymentAnnotationUpdater

type DeploymentAnnotationUpdater interface {
    Update(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o DeploymentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type DeploymentAnnotationUpserter

type DeploymentAnnotationUpserter interface {
    Upsert(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type DeploymentDeleter

type DeploymentDeleter interface {
    Delete(o *Deployment, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o DeploymentSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type DeploymentFinder

type DeploymentFinder interface {
    FindDeployment(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Deployment, error)
}

type DeploymentFinisher

type DeploymentFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Deployment, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (DeploymentSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type DeploymentInserter

type DeploymentInserter interface {
    Insert(o *Deployment, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type DeploymentLabel

DeploymentLabel is an object representing the database table.

type DeploymentLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *deploymentLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   deploymentLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindDeploymentLabel

func FindDeploymentLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DeploymentLabel, error)

FindDeploymentLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type DeploymentLabelDeleter

type DeploymentLabelDeleter interface {
    Delete(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o DeploymentLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type DeploymentLabelFinder

type DeploymentLabelFinder interface {
    FindDeploymentLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DeploymentLabel, error)
}

type DeploymentLabelFinisher

type DeploymentLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*DeploymentLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (DeploymentLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type DeploymentLabelInserter

type DeploymentLabelInserter interface {
    Insert(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type DeploymentLabelReloader

type DeploymentLabelReloader interface {
    Reload(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *DeploymentLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type DeploymentLabelSlice

DeploymentLabelSlice is an alias for a slice of pointers to DeploymentLabel. This should almost always be used instead of []DeploymentLabel.

type DeploymentLabelSlice []*DeploymentLabel

type DeploymentLabelUpdater

type DeploymentLabelUpdater interface {
    Update(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o DeploymentLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type DeploymentLabelUpserter

type DeploymentLabelUpserter interface {
    Upsert(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type DeploymentProcess

DeploymentProcess is an object representing the database table.

type DeploymentProcess struct {
    ID             int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID           string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt      time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt      null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ProcessGUID    null.String `boil:"process_guid" json:"process_guid,omitempty" toml:"process_guid" yaml:"process_guid,omitempty"`
    ProcessType    null.String `boil:"process_type" json:"process_type,omitempty" toml:"process_type" yaml:"process_type,omitempty"`
    DeploymentGUID null.String `boil:"deployment_guid" json:"deployment_guid,omitempty" toml:"deployment_guid" yaml:"deployment_guid,omitempty"`

    R   *deploymentProcessR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   deploymentProcessL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindDeploymentProcess

func FindDeploymentProcess(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DeploymentProcess, error)

FindDeploymentProcess retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type DeploymentProcessDeleter

type DeploymentProcessDeleter interface {
    Delete(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o DeploymentProcessSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type DeploymentProcessFinder

type DeploymentProcessFinder interface {
    FindDeploymentProcess(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DeploymentProcess, error)
}

type DeploymentProcessFinisher

type DeploymentProcessFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*DeploymentProcess, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (DeploymentProcessSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type DeploymentProcessInserter

type DeploymentProcessInserter interface {
    Insert(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type DeploymentProcessReloader

type DeploymentProcessReloader interface {
    Reload(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *DeploymentProcessSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type DeploymentProcessSlice

DeploymentProcessSlice is an alias for a slice of pointers to DeploymentProcess. This should almost always be used instead of []DeploymentProcess.

type DeploymentProcessSlice []*DeploymentProcess

type DeploymentProcessUpdater

type DeploymentProcessUpdater interface {
    Update(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o DeploymentProcessSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type DeploymentProcessUpserter

type DeploymentProcessUpserter interface {
    Upsert(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type DeploymentReloader

type DeploymentReloader interface {
    Reload(o *Deployment, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *DeploymentSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type DeploymentSlice

DeploymentSlice is an alias for a slice of pointers to Deployment. This should almost always be used instead of []Deployment.

type DeploymentSlice []*Deployment

type DeploymentUpdater

type DeploymentUpdater interface {
    Update(o *Deployment, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o DeploymentSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type DeploymentUpserter

type DeploymentUpserter interface {
    Upsert(o *Deployment, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Domain

Domain is an object representing the database table.

type Domain struct {
    ID                   int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                 string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt            time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt            null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                 string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    Wildcard             bool        `boil:"wildcard" json:"wildcard" toml:"wildcard" yaml:"wildcard"`
    OwningOrganizationID null.Int    `boil:"owning_organization_id" json:"owning_organization_id,omitempty" toml:"owning_organization_id" yaml:"owning_organization_id,omitempty"`
    RouterGroupGUID      null.String `boil:"router_group_guid" json:"router_group_guid,omitempty" toml:"router_group_guid" yaml:"router_group_guid,omitempty"`
    Internal             null.Bool   `boil:"internal" json:"internal,omitempty" toml:"internal" yaml:"internal,omitempty"`

    R   *domainR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   domainL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindDomain

func FindDomain(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Domain, error)

FindDomain retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type DomainAnnotation

DomainAnnotation is an object representing the database table.

type DomainAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *domainAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   domainAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindDomainAnnotation

func FindDomainAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DomainAnnotation, error)

FindDomainAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type DomainAnnotationDeleter

type DomainAnnotationDeleter interface {
    Delete(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o DomainAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type DomainAnnotationFinder

type DomainAnnotationFinder interface {
    FindDomainAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DomainAnnotation, error)
}

type DomainAnnotationFinisher

type DomainAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*DomainAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (DomainAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type DomainAnnotationInserter

type DomainAnnotationInserter interface {
    Insert(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type DomainAnnotationReloader

type DomainAnnotationReloader interface {
    Reload(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *DomainAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type DomainAnnotationSlice

DomainAnnotationSlice is an alias for a slice of pointers to DomainAnnotation. This should almost always be used instead of []DomainAnnotation.

type DomainAnnotationSlice []*DomainAnnotation

type DomainAnnotationUpdater

type DomainAnnotationUpdater interface {
    Update(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o DomainAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type DomainAnnotationUpserter

type DomainAnnotationUpserter interface {
    Upsert(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type DomainDeleter

type DomainDeleter interface {
    Delete(o *Domain, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o DomainSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type DomainFinder

type DomainFinder interface {
    FindDomain(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Domain, error)
}

type DomainFinisher

type DomainFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Domain, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (DomainSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type DomainInserter

type DomainInserter interface {
    Insert(o *Domain, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type DomainLabel

DomainLabel is an object representing the database table.

type DomainLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *domainLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   domainLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindDomainLabel

func FindDomainLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DomainLabel, error)

FindDomainLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type DomainLabelDeleter

type DomainLabelDeleter interface {
    Delete(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o DomainLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type DomainLabelFinder

type DomainLabelFinder interface {
    FindDomainLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DomainLabel, error)
}

type DomainLabelFinisher

type DomainLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*DomainLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (DomainLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type DomainLabelInserter

type DomainLabelInserter interface {
    Insert(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type DomainLabelReloader

type DomainLabelReloader interface {
    Reload(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *DomainLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type DomainLabelSlice

DomainLabelSlice is an alias for a slice of pointers to DomainLabel. This should almost always be used instead of []DomainLabel.

type DomainLabelSlice []*DomainLabel

type DomainLabelUpdater

type DomainLabelUpdater interface {
    Update(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o DomainLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type DomainLabelUpserter

type DomainLabelUpserter interface {
    Upsert(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type DomainReloader

type DomainReloader interface {
    Reload(o *Domain, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *DomainSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type DomainSlice

DomainSlice is an alias for a slice of pointers to Domain. This should almost always be used instead of []Domain.

type DomainSlice []*Domain

type DomainUpdater

type DomainUpdater interface {
    Update(o *Domain, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o DomainSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type DomainUpserter

type DomainUpserter interface {
    Upsert(o *Domain, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Droplet

Droplet is an object representing the database table.

type Droplet struct {
    ID                             int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                           string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt                      time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt                      null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    DropletHash                    null.String `boil:"droplet_hash" json:"droplet_hash,omitempty" toml:"droplet_hash" yaml:"droplet_hash,omitempty"`
    ExecutionMetadata              null.String `boil:"execution_metadata" json:"execution_metadata,omitempty" toml:"execution_metadata" yaml:"execution_metadata,omitempty"`
    State                          string      `boil:"state" json:"state" toml:"state" yaml:"state"`
    ProcessTypes                   null.String `boil:"process_types" json:"process_types,omitempty" toml:"process_types" yaml:"process_types,omitempty"`
    ErrorID                        null.String `boil:"error_id" json:"error_id,omitempty" toml:"error_id" yaml:"error_id,omitempty"`
    ErrorDescription               null.String `boil:"error_description" json:"error_description,omitempty" toml:"error_description" yaml:"error_description,omitempty"`
    EncryptedEnvironmentVariables  null.String `boil:"encrypted_environment_variables" json:"encrypted_environment_variables,omitempty" toml:"encrypted_environment_variables" yaml:"encrypted_environment_variables,omitempty"`
    Salt                           null.String `boil:"salt" json:"salt,omitempty" toml:"salt" yaml:"salt,omitempty"`
    StagingMemoryInMB              null.Int    `boil:"staging_memory_in_mb" json:"staging_memory_in_mb,omitempty" toml:"staging_memory_in_mb" yaml:"staging_memory_in_mb,omitempty"`
    StagingDiskInMB                null.Int    `boil:"staging_disk_in_mb" json:"staging_disk_in_mb,omitempty" toml:"staging_disk_in_mb" yaml:"staging_disk_in_mb,omitempty"`
    BuildpackReceiptBuildpack      null.String `boil:"buildpack_receipt_buildpack" json:"buildpack_receipt_buildpack,omitempty" toml:"buildpack_receipt_buildpack" yaml:"buildpack_receipt_buildpack,omitempty"`
    BuildpackReceiptBuildpackGUID  null.String `boil:"buildpack_receipt_buildpack_guid" json:"buildpack_receipt_buildpack_guid,omitempty" toml:"buildpack_receipt_buildpack_guid" yaml:"buildpack_receipt_buildpack_guid,omitempty"`
    BuildpackReceiptDetectOutput   null.String `boil:"buildpack_receipt_detect_output" json:"buildpack_receipt_detect_output,omitempty" toml:"buildpack_receipt_detect_output" yaml:"buildpack_receipt_detect_output,omitempty"`
    DockerReceiptImage             null.String `boil:"docker_receipt_image" json:"docker_receipt_image,omitempty" toml:"docker_receipt_image" yaml:"docker_receipt_image,omitempty"`
    PackageGUID                    null.String `boil:"package_guid" json:"package_guid,omitempty" toml:"package_guid" yaml:"package_guid,omitempty"`
    AppGUID                        null.String `boil:"app_guid" json:"app_guid,omitempty" toml:"app_guid" yaml:"app_guid,omitempty"`
    Sha256Checksum                 null.String `boil:"sha256_checksum" json:"sha256_checksum,omitempty" toml:"sha256_checksum" yaml:"sha256_checksum,omitempty"`
    BuildGUID                      null.String `boil:"build_guid" json:"build_guid,omitempty" toml:"build_guid" yaml:"build_guid,omitempty"`
    DockerReceiptUsername          null.String `boil:"docker_receipt_username" json:"docker_receipt_username,omitempty" toml:"docker_receipt_username" yaml:"docker_receipt_username,omitempty"`
    DockerReceiptPasswordSalt      null.String `boil:"docker_receipt_password_salt" json:"docker_receipt_password_salt,omitempty" toml:"docker_receipt_password_salt" yaml:"docker_receipt_password_salt,omitempty"`
    EncryptedDockerReceiptPassword null.String `boil:"encrypted_docker_receipt_password" json:"encrypted_docker_receipt_password,omitempty" toml:"encrypted_docker_receipt_password" yaml:"encrypted_docker_receipt_password,omitempty"`
    EncryptionKeyLabel             null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations           int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`
    Sidecars                       null.String `boil:"sidecars" json:"sidecars,omitempty" toml:"sidecars" yaml:"sidecars,omitempty"`

    R   *dropletR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   dropletL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindDroplet

func FindDroplet(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Droplet, error)

FindDroplet retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type DropletAnnotation

DropletAnnotation is an object representing the database table.

type DropletAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *dropletAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   dropletAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindDropletAnnotation

func FindDropletAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DropletAnnotation, error)

FindDropletAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type DropletAnnotationDeleter

type DropletAnnotationDeleter interface {
    Delete(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o DropletAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type DropletAnnotationFinder

type DropletAnnotationFinder interface {
    FindDropletAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DropletAnnotation, error)
}

type DropletAnnotationFinisher

type DropletAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*DropletAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (DropletAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type DropletAnnotationInserter

type DropletAnnotationInserter interface {
    Insert(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type DropletAnnotationReloader

type DropletAnnotationReloader interface {
    Reload(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *DropletAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type DropletAnnotationSlice

DropletAnnotationSlice is an alias for a slice of pointers to DropletAnnotation. This should almost always be used instead of []DropletAnnotation.

type DropletAnnotationSlice []*DropletAnnotation

type DropletAnnotationUpdater

type DropletAnnotationUpdater interface {
    Update(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o DropletAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type DropletAnnotationUpserter

type DropletAnnotationUpserter interface {
    Upsert(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type DropletDeleter

type DropletDeleter interface {
    Delete(o *Droplet, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o DropletSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type DropletFinder

type DropletFinder interface {
    FindDroplet(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Droplet, error)
}

type DropletFinisher

type DropletFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Droplet, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (DropletSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type DropletInserter

type DropletInserter interface {
    Insert(o *Droplet, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type DropletLabel

DropletLabel is an object representing the database table.

type DropletLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *dropletLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   dropletLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindDropletLabel

func FindDropletLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DropletLabel, error)

FindDropletLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type DropletLabelDeleter

type DropletLabelDeleter interface {
    Delete(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o DropletLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type DropletLabelFinder

type DropletLabelFinder interface {
    FindDropletLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*DropletLabel, error)
}

type DropletLabelFinisher

type DropletLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*DropletLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (DropletLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type DropletLabelInserter

type DropletLabelInserter interface {
    Insert(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type DropletLabelReloader

type DropletLabelReloader interface {
    Reload(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *DropletLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type DropletLabelSlice

DropletLabelSlice is an alias for a slice of pointers to DropletLabel. This should almost always be used instead of []DropletLabel.

type DropletLabelSlice []*DropletLabel

type DropletLabelUpdater

type DropletLabelUpdater interface {
    Update(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o DropletLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type DropletLabelUpserter

type DropletLabelUpserter interface {
    Upsert(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type DropletReloader

type DropletReloader interface {
    Reload(o *Droplet, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *DropletSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type DropletSlice

DropletSlice is an alias for a slice of pointers to Droplet. This should almost always be used instead of []Droplet.

type DropletSlice []*Droplet

type DropletUpdater

type DropletUpdater interface {
    Update(o *Droplet, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o DropletSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type DropletUpserter

type DropletUpserter interface {
    Upsert(o *Droplet, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type EncryptionKeySentinel

EncryptionKeySentinel is an object representing the database table.

type EncryptionKeySentinel struct {
    ID                   int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                 string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt            time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt            null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ExpectedValue        null.String `boil:"expected_value" json:"expected_value,omitempty" toml:"expected_value" yaml:"expected_value,omitempty"`
    EncryptedValue       null.String `boil:"encrypted_value" json:"encrypted_value,omitempty" toml:"encrypted_value" yaml:"encrypted_value,omitempty"`
    EncryptionKeyLabel   null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    Salt                 null.String `boil:"salt" json:"salt,omitempty" toml:"salt" yaml:"salt,omitempty"`
    EncryptionIterations int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`

    R   *encryptionKeySentinelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   encryptionKeySentinelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindEncryptionKeySentinel

func FindEncryptionKeySentinel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*EncryptionKeySentinel, error)

FindEncryptionKeySentinel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type EncryptionKeySentinelDeleter

type EncryptionKeySentinelDeleter interface {
    Delete(o *EncryptionKeySentinel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o EncryptionKeySentinelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type EncryptionKeySentinelFinder

type EncryptionKeySentinelFinder interface {
    FindEncryptionKeySentinel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*EncryptionKeySentinel, error)
}

type EncryptionKeySentinelFinisher

type EncryptionKeySentinelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*EncryptionKeySentinel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (EncryptionKeySentinelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type EncryptionKeySentinelInserter

type EncryptionKeySentinelInserter interface {
    Insert(o *EncryptionKeySentinel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type EncryptionKeySentinelReloader

type EncryptionKeySentinelReloader interface {
    Reload(o *EncryptionKeySentinel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *EncryptionKeySentinelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type EncryptionKeySentinelSlice

EncryptionKeySentinelSlice is an alias for a slice of pointers to EncryptionKeySentinel. This should almost always be used instead of []EncryptionKeySentinel.

type EncryptionKeySentinelSlice []*EncryptionKeySentinel

type EncryptionKeySentinelUpdater

type EncryptionKeySentinelUpdater interface {
    Update(o *EncryptionKeySentinel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o EncryptionKeySentinelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type EncryptionKeySentinelUpserter

type EncryptionKeySentinelUpserter interface {
    Upsert(o *EncryptionKeySentinel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type EnvGroup

EnvGroup is an object representing the database table.

type EnvGroup struct {
    ID                   int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                 string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt            time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt            null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                 string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    EnvironmentJSON      null.String `boil:"environment_json" json:"environment_json,omitempty" toml:"environment_json" yaml:"environment_json,omitempty"`
    Salt                 null.String `boil:"salt" json:"salt,omitempty" toml:"salt" yaml:"salt,omitempty"`
    EncryptionKeyLabel   null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`

    R   *envGroupR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   envGroupL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindEnvGroup

func FindEnvGroup(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*EnvGroup, error)

FindEnvGroup retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type EnvGroupDeleter

type EnvGroupDeleter interface {
    Delete(o *EnvGroup, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o EnvGroupSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type EnvGroupFinder

type EnvGroupFinder interface {
    FindEnvGroup(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*EnvGroup, error)
}

type EnvGroupFinisher

type EnvGroupFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*EnvGroup, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (EnvGroupSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type EnvGroupInserter

type EnvGroupInserter interface {
    Insert(o *EnvGroup, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type EnvGroupReloader

type EnvGroupReloader interface {
    Reload(o *EnvGroup, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *EnvGroupSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type EnvGroupSlice

EnvGroupSlice is an alias for a slice of pointers to EnvGroup. This should almost always be used instead of []EnvGroup.

type EnvGroupSlice []*EnvGroup

type EnvGroupUpdater

type EnvGroupUpdater interface {
    Update(o *EnvGroup, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o EnvGroupSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type EnvGroupUpserter

type EnvGroupUpserter interface {
    Upsert(o *EnvGroup, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Event

Event is an object representing the database table.

type Event struct {
    ID               int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID             string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt        time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt        null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Timestamp        time.Time   `boil:"timestamp" json:"timestamp" toml:"timestamp" yaml:"timestamp"`
    Type             string      `boil:"type" json:"type" toml:"type" yaml:"type"`
    Actor            string      `boil:"actor" json:"actor" toml:"actor" yaml:"actor"`
    ActorType        string      `boil:"actor_type" json:"actor_type" toml:"actor_type" yaml:"actor_type"`
    Actee            string      `boil:"actee" json:"actee" toml:"actee" yaml:"actee"`
    ActeeType        string      `boil:"actee_type" json:"actee_type" toml:"actee_type" yaml:"actee_type"`
    Metadata         null.String `boil:"metadata" json:"metadata,omitempty" toml:"metadata" yaml:"metadata,omitempty"`
    OrganizationGUID string      `boil:"organization_guid" json:"organization_guid" toml:"organization_guid" yaml:"organization_guid"`
    SpaceGUID        string      `boil:"space_guid" json:"space_guid" toml:"space_guid" yaml:"space_guid"`
    ActorName        null.String `boil:"actor_name" json:"actor_name,omitempty" toml:"actor_name" yaml:"actor_name,omitempty"`
    ActeeName        null.String `boil:"actee_name" json:"actee_name,omitempty" toml:"actee_name" yaml:"actee_name,omitempty"`
    ActorUsername    null.String `boil:"actor_username" json:"actor_username,omitempty" toml:"actor_username" yaml:"actor_username,omitempty"`

    R   *eventR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   eventL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindEvent

func FindEvent(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Event, error)

FindEvent retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type EventDeleter

type EventDeleter interface {
    Delete(o *Event, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o EventSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type EventFinder

type EventFinder interface {
    FindEvent(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Event, error)
}

type EventFinisher

type EventFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Event, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (EventSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type EventInserter

type EventInserter interface {
    Insert(o *Event, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type EventReloader

type EventReloader interface {
    Reload(o *Event, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *EventSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type EventSlice

EventSlice is an alias for a slice of pointers to Event. This should almost always be used instead of []Event.

type EventSlice []*Event

type EventUpdater

type EventUpdater interface {
    Update(o *Event, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o EventSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type EventUpserter

type EventUpserter interface {
    Upsert(o *Event, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type FeatureFlag

FeatureFlag is an object representing the database table.

type FeatureFlag struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name         string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    Enabled      bool        `boil:"enabled" json:"enabled" toml:"enabled" yaml:"enabled"`
    ErrorMessage null.String `boil:"error_message" json:"error_message,omitempty" toml:"error_message" yaml:"error_message,omitempty"`

    R   *featureFlagR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   featureFlagL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindFeatureFlag

func FindFeatureFlag(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*FeatureFlag, error)

FindFeatureFlag retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type FeatureFlagDeleter

type FeatureFlagDeleter interface {
    Delete(o *FeatureFlag, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o FeatureFlagSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type FeatureFlagFinder

type FeatureFlagFinder interface {
    FindFeatureFlag(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*FeatureFlag, error)
}

type FeatureFlagFinisher

type FeatureFlagFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*FeatureFlag, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (FeatureFlagSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type FeatureFlagInserter

type FeatureFlagInserter interface {
    Insert(o *FeatureFlag, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type FeatureFlagReloader

type FeatureFlagReloader interface {
    Reload(o *FeatureFlag, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *FeatureFlagSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type FeatureFlagSlice

FeatureFlagSlice is an alias for a slice of pointers to FeatureFlag. This should almost always be used instead of []FeatureFlag.

type FeatureFlagSlice []*FeatureFlag

type FeatureFlagUpdater

type FeatureFlagUpdater interface {
    Update(o *FeatureFlag, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o FeatureFlagSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type FeatureFlagUpserter

type FeatureFlagUpserter interface {
    Upsert(o *FeatureFlag, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type IsolationSegment

IsolationSegment is an object representing the database table.

type IsolationSegment struct {
    ID        int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID      string    `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name      string    `boil:"name" json:"name" toml:"name" yaml:"name"`

    R   *isolationSegmentR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   isolationSegmentL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindIsolationSegment

func FindIsolationSegment(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*IsolationSegment, error)

FindIsolationSegment retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type IsolationSegmentAnnotation

IsolationSegmentAnnotation is an object representing the database table.

type IsolationSegmentAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *isolationSegmentAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   isolationSegmentAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindIsolationSegmentAnnotation

func FindIsolationSegmentAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*IsolationSegmentAnnotation, error)

FindIsolationSegmentAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type IsolationSegmentAnnotationDeleter

type IsolationSegmentAnnotationDeleter interface {
    Delete(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o IsolationSegmentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type IsolationSegmentAnnotationFinder

type IsolationSegmentAnnotationFinder interface {
    FindIsolationSegmentAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*IsolationSegmentAnnotation, error)
}

type IsolationSegmentAnnotationFinisher

type IsolationSegmentAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*IsolationSegmentAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (IsolationSegmentAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type IsolationSegmentAnnotationInserter

type IsolationSegmentAnnotationInserter interface {
    Insert(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type IsolationSegmentAnnotationReloader

type IsolationSegmentAnnotationReloader interface {
    Reload(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *IsolationSegmentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type IsolationSegmentAnnotationSlice

IsolationSegmentAnnotationSlice is an alias for a slice of pointers to IsolationSegmentAnnotation. This should almost always be used instead of []IsolationSegmentAnnotation.

type IsolationSegmentAnnotationSlice []*IsolationSegmentAnnotation

type IsolationSegmentAnnotationUpdater

type IsolationSegmentAnnotationUpdater interface {
    Update(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o IsolationSegmentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type IsolationSegmentAnnotationUpserter

type IsolationSegmentAnnotationUpserter interface {
    Upsert(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type IsolationSegmentDeleter

type IsolationSegmentDeleter interface {
    Delete(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o IsolationSegmentSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type IsolationSegmentFinder

type IsolationSegmentFinder interface {
    FindIsolationSegment(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*IsolationSegment, error)
}

type IsolationSegmentFinisher

type IsolationSegmentFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*IsolationSegment, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (IsolationSegmentSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type IsolationSegmentInserter

type IsolationSegmentInserter interface {
    Insert(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type IsolationSegmentLabel

IsolationSegmentLabel is an object representing the database table.

type IsolationSegmentLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *isolationSegmentLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   isolationSegmentLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindIsolationSegmentLabel

func FindIsolationSegmentLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*IsolationSegmentLabel, error)

FindIsolationSegmentLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type IsolationSegmentLabelDeleter

type IsolationSegmentLabelDeleter interface {
    Delete(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o IsolationSegmentLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type IsolationSegmentLabelFinder

type IsolationSegmentLabelFinder interface {
    FindIsolationSegmentLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*IsolationSegmentLabel, error)
}

type IsolationSegmentLabelFinisher

type IsolationSegmentLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*IsolationSegmentLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (IsolationSegmentLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type IsolationSegmentLabelInserter

type IsolationSegmentLabelInserter interface {
    Insert(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type IsolationSegmentLabelReloader

type IsolationSegmentLabelReloader interface {
    Reload(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *IsolationSegmentLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type IsolationSegmentLabelSlice

IsolationSegmentLabelSlice is an alias for a slice of pointers to IsolationSegmentLabel. This should almost always be used instead of []IsolationSegmentLabel.

type IsolationSegmentLabelSlice []*IsolationSegmentLabel

type IsolationSegmentLabelUpdater

type IsolationSegmentLabelUpdater interface {
    Update(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o IsolationSegmentLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type IsolationSegmentLabelUpserter

type IsolationSegmentLabelUpserter interface {
    Upsert(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type IsolationSegmentReloader

type IsolationSegmentReloader interface {
    Reload(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *IsolationSegmentSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type IsolationSegmentSlice

IsolationSegmentSlice is an alias for a slice of pointers to IsolationSegment. This should almost always be used instead of []IsolationSegment.

type IsolationSegmentSlice []*IsolationSegment

type IsolationSegmentUpdater

type IsolationSegmentUpdater interface {
    Update(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o IsolationSegmentSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type IsolationSegmentUpserter

type IsolationSegmentUpserter interface {
    Upsert(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Job

Job is an object representing the database table.

type Job struct {
    ID             int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID           string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt      time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt      null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    State          null.String `boil:"state" json:"state,omitempty" toml:"state" yaml:"state,omitempty"`
    Operation      null.String `boil:"operation" json:"operation,omitempty" toml:"operation" yaml:"operation,omitempty"`
    ResourceGUID   null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    ResourceType   null.String `boil:"resource_type" json:"resource_type,omitempty" toml:"resource_type" yaml:"resource_type,omitempty"`
    DelayedJobGUID null.String `boil:"delayed_job_guid" json:"delayed_job_guid,omitempty" toml:"delayed_job_guid" yaml:"delayed_job_guid,omitempty"`
    CFAPIError     null.String `boil:"cf_api_error" json:"cf_api_error,omitempty" toml:"cf_api_error" yaml:"cf_api_error,omitempty"`

    R   *jobR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   jobL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindJob

func FindJob(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Job, error)

FindJob retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type JobDeleter

type JobDeleter interface {
    Delete(o *Job, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o JobSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type JobFinder

type JobFinder interface {
    FindJob(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Job, error)
}

type JobFinisher

type JobFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Job, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (JobSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type JobInserter

type JobInserter interface {
    Insert(o *Job, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type JobReloader

type JobReloader interface {
    Reload(o *Job, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *JobSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type JobSlice

JobSlice is an alias for a slice of pointers to Job. This should almost always be used instead of []Job.

type JobSlice []*Job

type JobUpdater

type JobUpdater interface {
    Update(o *Job, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o JobSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type JobUpserter

type JobUpserter interface {
    Upsert(o *Job, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type JobWarning

JobWarning is an object representing the database table.

type JobWarning struct {
    ID        int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID      string    `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Detail    string    `boil:"detail" json:"detail" toml:"detail" yaml:"detail"`
    JobID     int       `boil:"job_id" json:"job_id" toml:"job_id" yaml:"job_id"`
    FKJobsID  null.Int  `boil:"fk_jobs_id" json:"fk_jobs_id,omitempty" toml:"fk_jobs_id" yaml:"fk_jobs_id,omitempty"`

    R   *jobWarningR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   jobWarningL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindJobWarning

func FindJobWarning(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*JobWarning, error)

FindJobWarning retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type JobWarningDeleter

type JobWarningDeleter interface {
    Delete(o *JobWarning, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o JobWarningSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type JobWarningFinder

type JobWarningFinder interface {
    FindJobWarning(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*JobWarning, error)
}

type JobWarningFinisher

type JobWarningFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*JobWarning, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (JobWarningSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type JobWarningInserter

type JobWarningInserter interface {
    Insert(o *JobWarning, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type JobWarningReloader

type JobWarningReloader interface {
    Reload(o *JobWarning, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *JobWarningSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type JobWarningSlice

JobWarningSlice is an alias for a slice of pointers to JobWarning. This should almost always be used instead of []JobWarning.

type JobWarningSlice []*JobWarning

type JobWarningUpdater

type JobWarningUpdater interface {
    Update(o *JobWarning, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o JobWarningSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type JobWarningUpserter

type JobWarningUpserter interface {
    Upsert(o *JobWarning, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type KpackLifecycleDatum

KpackLifecycleDatum is an object representing the database table.

type KpackLifecycleDatum struct {
    ID          int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID        string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt   time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt   null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    BuildGUID   null.String `boil:"build_guid" json:"build_guid,omitempty" toml:"build_guid" yaml:"build_guid,omitempty"`
    DropletGUID null.String `boil:"droplet_guid" json:"droplet_guid,omitempty" toml:"droplet_guid" yaml:"droplet_guid,omitempty"`
    AppGUID     null.String `boil:"app_guid" json:"app_guid,omitempty" toml:"app_guid" yaml:"app_guid,omitempty"`
    Buildpacks  null.String `boil:"buildpacks" json:"buildpacks,omitempty" toml:"buildpacks" yaml:"buildpacks,omitempty"`

    R   *kpackLifecycleDatumR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   kpackLifecycleDatumL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindKpackLifecycleDatum

func FindKpackLifecycleDatum(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*KpackLifecycleDatum, error)

FindKpackLifecycleDatum retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type KpackLifecycleDatumDeleter

type KpackLifecycleDatumDeleter interface {
    Delete(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o KpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type KpackLifecycleDatumFinder

type KpackLifecycleDatumFinder interface {
    FindKpackLifecycleDatum(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*KpackLifecycleDatum, error)
}

type KpackLifecycleDatumFinisher

type KpackLifecycleDatumFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*KpackLifecycleDatum, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (KpackLifecycleDatumSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type KpackLifecycleDatumInserter

type KpackLifecycleDatumInserter interface {
    Insert(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type KpackLifecycleDatumReloader

type KpackLifecycleDatumReloader interface {
    Reload(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *KpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type KpackLifecycleDatumSlice

KpackLifecycleDatumSlice is an alias for a slice of pointers to KpackLifecycleDatum. This should almost always be used instead of []KpackLifecycleDatum.

type KpackLifecycleDatumSlice []*KpackLifecycleDatum

type KpackLifecycleDatumUpdater

type KpackLifecycleDatumUpdater interface {
    Update(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o KpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type KpackLifecycleDatumUpserter

type KpackLifecycleDatumUpserter interface {
    Upsert(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Locking

Locking is an object representing the database table.

type Locking struct {
    ID   int    `boil:"id" json:"id" toml:"id" yaml:"id"`
    Name string `boil:"name" json:"name" toml:"name" yaml:"name"`

    R   *lockingR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   lockingL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindLocking

func FindLocking(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Locking, error)

FindLocking retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type LockingDeleter

type LockingDeleter interface {
    Delete(o *Locking, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o LockingSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type LockingFinder

type LockingFinder interface {
    FindLocking(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Locking, error)
}

type LockingFinisher

type LockingFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Locking, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (LockingSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type LockingInserter

type LockingInserter interface {
    Insert(o *Locking, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type LockingReloader

type LockingReloader interface {
    Reload(o *Locking, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *LockingSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type LockingSlice

LockingSlice is an alias for a slice of pointers to Locking. This should almost always be used instead of []Locking.

type LockingSlice []*Locking

type LockingUpdater

type LockingUpdater interface {
    Update(o *Locking, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o LockingSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type LockingUpserter

type LockingUpserter interface {
    Upsert(o *Locking, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type M

M type is for providing columns and column values to UpdateAll.

type M map[string]interface{}

type Organization

Organization is an object representing the database table.

type Organization struct {
    ID                          int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                        string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt                   time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt                   null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                        string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    BillingEnabled              bool        `boil:"billing_enabled" json:"billing_enabled" toml:"billing_enabled" yaml:"billing_enabled"`
    QuotaDefinitionID           int         `boil:"quota_definition_id" json:"quota_definition_id" toml:"quota_definition_id" yaml:"quota_definition_id"`
    Status                      null.String `boil:"status" json:"status,omitempty" toml:"status" yaml:"status,omitempty"`
    DefaultIsolationSegmentGUID null.String `boil:"default_isolation_segment_guid" json:"default_isolation_segment_guid,omitempty" toml:"default_isolation_segment_guid" yaml:"default_isolation_segment_guid,omitempty"`

    R   *organizationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   organizationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindOrganization

func FindOrganization(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Organization, error)

FindOrganization retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type OrganizationAnnotation

OrganizationAnnotation is an object representing the database table.

type OrganizationAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *organizationAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   organizationAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindOrganizationAnnotation

func FindOrganizationAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*OrganizationAnnotation, error)

FindOrganizationAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type OrganizationAnnotationDeleter

type OrganizationAnnotationDeleter interface {
    Delete(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o OrganizationAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type OrganizationAnnotationFinder

type OrganizationAnnotationFinder interface {
    FindOrganizationAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*OrganizationAnnotation, error)
}

type OrganizationAnnotationFinisher

type OrganizationAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (OrganizationAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type OrganizationAnnotationInserter

type OrganizationAnnotationInserter interface {
    Insert(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type OrganizationAnnotationReloader

type OrganizationAnnotationReloader interface {
    Reload(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *OrganizationAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type OrganizationAnnotationSlice

OrganizationAnnotationSlice is an alias for a slice of pointers to OrganizationAnnotation. This should almost always be used instead of []OrganizationAnnotation.

type OrganizationAnnotationSlice []*OrganizationAnnotation

type OrganizationAnnotationUpdater

type OrganizationAnnotationUpdater interface {
    Update(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o OrganizationAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type OrganizationAnnotationUpserter

type OrganizationAnnotationUpserter interface {
    Upsert(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type OrganizationDeleter

type OrganizationDeleter interface {
    Delete(o *Organization, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o OrganizationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type OrganizationFinder

type OrganizationFinder interface {
    FindOrganization(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Organization, error)
}

type OrganizationFinisher

type OrganizationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Organization, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (OrganizationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type OrganizationInserter

type OrganizationInserter interface {
    Insert(o *Organization, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type OrganizationLabel

OrganizationLabel is an object representing the database table.

type OrganizationLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *organizationLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   organizationLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindOrganizationLabel

func FindOrganizationLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*OrganizationLabel, error)

FindOrganizationLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type OrganizationLabelDeleter

type OrganizationLabelDeleter interface {
    Delete(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o OrganizationLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type OrganizationLabelFinder

type OrganizationLabelFinder interface {
    FindOrganizationLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*OrganizationLabel, error)
}

type OrganizationLabelFinisher

type OrganizationLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (OrganizationLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type OrganizationLabelInserter

type OrganizationLabelInserter interface {
    Insert(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type OrganizationLabelReloader

type OrganizationLabelReloader interface {
    Reload(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *OrganizationLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type OrganizationLabelSlice

OrganizationLabelSlice is an alias for a slice of pointers to OrganizationLabel. This should almost always be used instead of []OrganizationLabel.

type OrganizationLabelSlice []*OrganizationLabel

type OrganizationLabelUpdater

type OrganizationLabelUpdater interface {
    Update(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o OrganizationLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type OrganizationLabelUpserter

type OrganizationLabelUpserter interface {
    Upsert(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type OrganizationReloader

type OrganizationReloader interface {
    Reload(o *Organization, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *OrganizationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type OrganizationSlice

OrganizationSlice is an alias for a slice of pointers to Organization. This should almost always be used instead of []Organization.

type OrganizationSlice []*Organization

type OrganizationUpdater

type OrganizationUpdater interface {
    Update(o *Organization, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o OrganizationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type OrganizationUpserter

type OrganizationUpserter interface {
    Upsert(o *Organization, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type OrganizationsAuditor

OrganizationsAuditor is an object representing the database table.

type OrganizationsAuditor struct {
    OrganizationID          int         `boil:"organization_id" json:"organization_id" toml:"organization_id" yaml:"organization_id"`
    UserID                  int         `boil:"user_id" json:"user_id" toml:"user_id" yaml:"user_id"`
    OrganizationsAuditorsPK int         `boil:"organizations_auditors_pk" json:"organizations_auditors_pk" toml:"organizations_auditors_pk" yaml:"organizations_auditors_pk"`
    RoleGUID                null.String `boil:"role_guid" json:"role_guid,omitempty" toml:"role_guid" yaml:"role_guid,omitempty"`
    CreatedAt               time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt               time.Time   `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`

    R   *organizationsAuditorR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   organizationsAuditorL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindOrganizationsAuditor

func FindOrganizationsAuditor(ctx context.Context, exec boil.ContextExecutor, organizationsAuditorsPK int, selectCols ...string) (*OrganizationsAuditor, error)

FindOrganizationsAuditor retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type OrganizationsAuditorDeleter

type OrganizationsAuditorDeleter interface {
    Delete(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o OrganizationsAuditorSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type OrganizationsAuditorFinder

type OrganizationsAuditorFinder interface {
    FindOrganizationsAuditor(ctx context.Context, exec boil.ContextExecutor, organizationsAuditorsPK int, selectCols ...string) (*OrganizationsAuditor, error)
}

type OrganizationsAuditorFinisher

type OrganizationsAuditorFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationsAuditor, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (OrganizationsAuditorSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type OrganizationsAuditorInserter

type OrganizationsAuditorInserter interface {
    Insert(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type OrganizationsAuditorReloader

type OrganizationsAuditorReloader interface {
    Reload(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *OrganizationsAuditorSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type OrganizationsAuditorSlice

OrganizationsAuditorSlice is an alias for a slice of pointers to OrganizationsAuditor. This should almost always be used instead of []OrganizationsAuditor.

type OrganizationsAuditorSlice []*OrganizationsAuditor

type OrganizationsAuditorUpdater

type OrganizationsAuditorUpdater interface {
    Update(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o OrganizationsAuditorSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type OrganizationsAuditorUpserter

type OrganizationsAuditorUpserter interface {
    Upsert(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type OrganizationsBillingManager

OrganizationsBillingManager is an object representing the database table.

type OrganizationsBillingManager struct {
    OrganizationID                 int         `boil:"organization_id" json:"organization_id" toml:"organization_id" yaml:"organization_id"`
    UserID                         int         `boil:"user_id" json:"user_id" toml:"user_id" yaml:"user_id"`
    OrganizationsBillingManagersPK int         `boil:"organizations_billing_managers_pk" json:"organizations_billing_managers_pk" toml:"organizations_billing_managers_pk" yaml:"organizations_billing_managers_pk"`
    RoleGUID                       null.String `boil:"role_guid" json:"role_guid,omitempty" toml:"role_guid" yaml:"role_guid,omitempty"`
    CreatedAt                      time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt                      time.Time   `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`

    R   *organizationsBillingManagerR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   organizationsBillingManagerL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindOrganizationsBillingManager

func FindOrganizationsBillingManager(ctx context.Context, exec boil.ContextExecutor, organizationsBillingManagersPK int, selectCols ...string) (*OrganizationsBillingManager, error)

FindOrganizationsBillingManager retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type OrganizationsBillingManagerDeleter

type OrganizationsBillingManagerDeleter interface {
    Delete(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o OrganizationsBillingManagerSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type OrganizationsBillingManagerFinder

type OrganizationsBillingManagerFinder interface {
    FindOrganizationsBillingManager(ctx context.Context, exec boil.ContextExecutor, organizationsBillingManagersPK int, selectCols ...string) (*OrganizationsBillingManager, error)
}

type OrganizationsBillingManagerFinisher

type OrganizationsBillingManagerFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationsBillingManager, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (OrganizationsBillingManagerSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type OrganizationsBillingManagerInserter

type OrganizationsBillingManagerInserter interface {
    Insert(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type OrganizationsBillingManagerReloader

type OrganizationsBillingManagerReloader interface {
    Reload(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *OrganizationsBillingManagerSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type OrganizationsBillingManagerSlice

OrganizationsBillingManagerSlice is an alias for a slice of pointers to OrganizationsBillingManager. This should almost always be used instead of []OrganizationsBillingManager.

type OrganizationsBillingManagerSlice []*OrganizationsBillingManager

type OrganizationsBillingManagerUpdater

type OrganizationsBillingManagerUpdater interface {
    Update(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o OrganizationsBillingManagerSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type OrganizationsBillingManagerUpserter

type OrganizationsBillingManagerUpserter interface {
    Upsert(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type OrganizationsManager

OrganizationsManager is an object representing the database table.

type OrganizationsManager struct {
    OrganizationID          int         `boil:"organization_id" json:"organization_id" toml:"organization_id" yaml:"organization_id"`
    UserID                  int         `boil:"user_id" json:"user_id" toml:"user_id" yaml:"user_id"`
    OrganizationsManagersPK int         `boil:"organizations_managers_pk" json:"organizations_managers_pk" toml:"organizations_managers_pk" yaml:"organizations_managers_pk"`
    RoleGUID                null.String `boil:"role_guid" json:"role_guid,omitempty" toml:"role_guid" yaml:"role_guid,omitempty"`
    CreatedAt               time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt               time.Time   `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`

    R   *organizationsManagerR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   organizationsManagerL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindOrganizationsManager

func FindOrganizationsManager(ctx context.Context, exec boil.ContextExecutor, organizationsManagersPK int, selectCols ...string) (*OrganizationsManager, error)

FindOrganizationsManager retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type OrganizationsManagerDeleter

type OrganizationsManagerDeleter interface {
    Delete(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o OrganizationsManagerSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type OrganizationsManagerFinder

type OrganizationsManagerFinder interface {
    FindOrganizationsManager(ctx context.Context, exec boil.ContextExecutor, organizationsManagersPK int, selectCols ...string) (*OrganizationsManager, error)
}

type OrganizationsManagerFinisher

type OrganizationsManagerFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationsManager, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (OrganizationsManagerSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type OrganizationsManagerInserter

type OrganizationsManagerInserter interface {
    Insert(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type OrganizationsManagerReloader

type OrganizationsManagerReloader interface {
    Reload(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *OrganizationsManagerSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type OrganizationsManagerSlice

OrganizationsManagerSlice is an alias for a slice of pointers to OrganizationsManager. This should almost always be used instead of []OrganizationsManager.

type OrganizationsManagerSlice []*OrganizationsManager

type OrganizationsManagerUpdater

type OrganizationsManagerUpdater interface {
    Update(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o OrganizationsManagerSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type OrganizationsManagerUpserter

type OrganizationsManagerUpserter interface {
    Upsert(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type OrganizationsPrivateDomain

OrganizationsPrivateDomain is an object representing the database table.

type OrganizationsPrivateDomain struct {
    OrganizationID                int `boil:"organization_id" json:"organization_id" toml:"organization_id" yaml:"organization_id"`
    PrivateDomainID               int `boil:"private_domain_id" json:"private_domain_id" toml:"private_domain_id" yaml:"private_domain_id"`
    OrganizationsPrivateDomainsPK int `boil:"organizations_private_domains_pk" json:"organizations_private_domains_pk" toml:"organizations_private_domains_pk" yaml:"organizations_private_domains_pk"`

    R   *organizationsPrivateDomainR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   organizationsPrivateDomainL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindOrganizationsPrivateDomain

func FindOrganizationsPrivateDomain(ctx context.Context, exec boil.ContextExecutor, organizationsPrivateDomainsPK int, selectCols ...string) (*OrganizationsPrivateDomain, error)

FindOrganizationsPrivateDomain retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type OrganizationsPrivateDomainDeleter

type OrganizationsPrivateDomainDeleter interface {
    Delete(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o OrganizationsPrivateDomainSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type OrganizationsPrivateDomainFinder

type OrganizationsPrivateDomainFinder interface {
    FindOrganizationsPrivateDomain(ctx context.Context, exec boil.ContextExecutor, organizationsPrivateDomainsPK int, selectCols ...string) (*OrganizationsPrivateDomain, error)
}

type OrganizationsPrivateDomainFinisher

type OrganizationsPrivateDomainFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationsPrivateDomain, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (OrganizationsPrivateDomainSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type OrganizationsPrivateDomainInserter

type OrganizationsPrivateDomainInserter interface {
    Insert(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type OrganizationsPrivateDomainReloader

type OrganizationsPrivateDomainReloader interface {
    Reload(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *OrganizationsPrivateDomainSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type OrganizationsPrivateDomainSlice

OrganizationsPrivateDomainSlice is an alias for a slice of pointers to OrganizationsPrivateDomain. This should almost always be used instead of []OrganizationsPrivateDomain.

type OrganizationsPrivateDomainSlice []*OrganizationsPrivateDomain

type OrganizationsPrivateDomainUpdater

type OrganizationsPrivateDomainUpdater interface {
    Update(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o OrganizationsPrivateDomainSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type OrganizationsPrivateDomainUpserter

type OrganizationsPrivateDomainUpserter interface {
    Upsert(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type OrganizationsUser

OrganizationsUser is an object representing the database table.

type OrganizationsUser struct {
    OrganizationID       int         `boil:"organization_id" json:"organization_id" toml:"organization_id" yaml:"organization_id"`
    UserID               int         `boil:"user_id" json:"user_id" toml:"user_id" yaml:"user_id"`
    OrganizationsUsersPK int         `boil:"organizations_users_pk" json:"organizations_users_pk" toml:"organizations_users_pk" yaml:"organizations_users_pk"`
    RoleGUID             null.String `boil:"role_guid" json:"role_guid,omitempty" toml:"role_guid" yaml:"role_guid,omitempty"`
    CreatedAt            time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt            time.Time   `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`

    R   *organizationsUserR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   organizationsUserL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindOrganizationsUser

func FindOrganizationsUser(ctx context.Context, exec boil.ContextExecutor, organizationsUsersPK int, selectCols ...string) (*OrganizationsUser, error)

FindOrganizationsUser retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type OrganizationsUserDeleter

type OrganizationsUserDeleter interface {
    Delete(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o OrganizationsUserSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type OrganizationsUserFinder

type OrganizationsUserFinder interface {
    FindOrganizationsUser(ctx context.Context, exec boil.ContextExecutor, organizationsUsersPK int, selectCols ...string) (*OrganizationsUser, error)
}

type OrganizationsUserFinisher

type OrganizationsUserFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationsUser, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (OrganizationsUserSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type OrganizationsUserInserter

type OrganizationsUserInserter interface {
    Insert(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type OrganizationsUserReloader

type OrganizationsUserReloader interface {
    Reload(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *OrganizationsUserSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type OrganizationsUserSlice

OrganizationsUserSlice is an alias for a slice of pointers to OrganizationsUser. This should almost always be used instead of []OrganizationsUser.

type OrganizationsUserSlice []*OrganizationsUser

type OrganizationsUserUpdater

type OrganizationsUserUpdater interface {
    Update(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o OrganizationsUserSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type OrganizationsUserUpserter

type OrganizationsUserUpserter interface {
    Upsert(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type OrphanedBlob

OrphanedBlob is an object representing the database table.

type OrphanedBlob struct {
    ID            int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID          string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt     time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt     null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    BlobKey       null.String `boil:"blob_key" json:"blob_key,omitempty" toml:"blob_key" yaml:"blob_key,omitempty"`
    DirtyCount    null.Int    `boil:"dirty_count" json:"dirty_count,omitempty" toml:"dirty_count" yaml:"dirty_count,omitempty"`
    BlobstoreType null.String `boil:"blobstore_type" json:"blobstore_type,omitempty" toml:"blobstore_type" yaml:"blobstore_type,omitempty"`

    R   *orphanedBlobR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   orphanedBlobL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindOrphanedBlob

func FindOrphanedBlob(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*OrphanedBlob, error)

FindOrphanedBlob retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type OrphanedBlobDeleter

type OrphanedBlobDeleter interface {
    Delete(o *OrphanedBlob, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o OrphanedBlobSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type OrphanedBlobFinder

type OrphanedBlobFinder interface {
    FindOrphanedBlob(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*OrphanedBlob, error)
}

type OrphanedBlobFinisher

type OrphanedBlobFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*OrphanedBlob, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (OrphanedBlobSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type OrphanedBlobInserter

type OrphanedBlobInserter interface {
    Insert(o *OrphanedBlob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type OrphanedBlobReloader

type OrphanedBlobReloader interface {
    Reload(o *OrphanedBlob, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *OrphanedBlobSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type OrphanedBlobSlice

OrphanedBlobSlice is an alias for a slice of pointers to OrphanedBlob. This should almost always be used instead of []OrphanedBlob.

type OrphanedBlobSlice []*OrphanedBlob

type OrphanedBlobUpdater

type OrphanedBlobUpdater interface {
    Update(o *OrphanedBlob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o OrphanedBlobSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type OrphanedBlobUpserter

type OrphanedBlobUpserter interface {
    Upsert(o *OrphanedBlob, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Package

Package is an object representing the database table.

type Package struct {
    ID                      int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                    string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt               time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt               null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Type                    null.String `boil:"type" json:"type,omitempty" toml:"type" yaml:"type,omitempty"`
    PackageHash             null.String `boil:"package_hash" json:"package_hash,omitempty" toml:"package_hash" yaml:"package_hash,omitempty"`
    State                   string      `boil:"state" json:"state" toml:"state" yaml:"state"`
    Error                   null.String `boil:"error" json:"error,omitempty" toml:"error" yaml:"error,omitempty"`
    AppGUID                 null.String `boil:"app_guid" json:"app_guid,omitempty" toml:"app_guid" yaml:"app_guid,omitempty"`
    DockerImage             null.String `boil:"docker_image" json:"docker_image,omitempty" toml:"docker_image" yaml:"docker_image,omitempty"`
    Sha256Checksum          null.String `boil:"sha256_checksum" json:"sha256_checksum,omitempty" toml:"sha256_checksum" yaml:"sha256_checksum,omitempty"`
    DockerUsername          null.String `boil:"docker_username" json:"docker_username,omitempty" toml:"docker_username" yaml:"docker_username,omitempty"`
    DockerPasswordSalt      null.String `boil:"docker_password_salt" json:"docker_password_salt,omitempty" toml:"docker_password_salt" yaml:"docker_password_salt,omitempty"`
    EncryptedDockerPassword null.String `boil:"encrypted_docker_password" json:"encrypted_docker_password,omitempty" toml:"encrypted_docker_password" yaml:"encrypted_docker_password,omitempty"`
    EncryptionKeyLabel      null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations    int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`

    R   *packageR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   packageL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindPackage

func FindPackage(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Package, error)

FindPackage retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type PackageAnnotation

PackageAnnotation is an object representing the database table.

type PackageAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *packageAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   packageAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindPackageAnnotation

func FindPackageAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*PackageAnnotation, error)

FindPackageAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type PackageAnnotationDeleter

type PackageAnnotationDeleter interface {
    Delete(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o PackageAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type PackageAnnotationFinder

type PackageAnnotationFinder interface {
    FindPackageAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*PackageAnnotation, error)
}

type PackageAnnotationFinisher

type PackageAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*PackageAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (PackageAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type PackageAnnotationInserter

type PackageAnnotationInserter interface {
    Insert(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type PackageAnnotationReloader

type PackageAnnotationReloader interface {
    Reload(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *PackageAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type PackageAnnotationSlice

PackageAnnotationSlice is an alias for a slice of pointers to PackageAnnotation. This should almost always be used instead of []PackageAnnotation.

type PackageAnnotationSlice []*PackageAnnotation

type PackageAnnotationUpdater

type PackageAnnotationUpdater interface {
    Update(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o PackageAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type PackageAnnotationUpserter

type PackageAnnotationUpserter interface {
    Upsert(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type PackageDeleter

type PackageDeleter interface {
    Delete(o *Package, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o PackageSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type PackageFinder

type PackageFinder interface {
    FindPackage(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Package, error)
}

type PackageFinisher

type PackageFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Package, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (PackageSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type PackageInserter

type PackageInserter interface {
    Insert(o *Package, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type PackageLabel

PackageLabel is an object representing the database table.

type PackageLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *packageLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   packageLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindPackageLabel

func FindPackageLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*PackageLabel, error)

FindPackageLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type PackageLabelDeleter

type PackageLabelDeleter interface {
    Delete(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o PackageLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type PackageLabelFinder

type PackageLabelFinder interface {
    FindPackageLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*PackageLabel, error)
}

type PackageLabelFinisher

type PackageLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*PackageLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (PackageLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type PackageLabelInserter

type PackageLabelInserter interface {
    Insert(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type PackageLabelReloader

type PackageLabelReloader interface {
    Reload(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *PackageLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type PackageLabelSlice

PackageLabelSlice is an alias for a slice of pointers to PackageLabel. This should almost always be used instead of []PackageLabel.

type PackageLabelSlice []*PackageLabel

type PackageLabelUpdater

type PackageLabelUpdater interface {
    Update(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o PackageLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type PackageLabelUpserter

type PackageLabelUpserter interface {
    Upsert(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type PackageReloader

type PackageReloader interface {
    Reload(o *Package, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *PackageSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type PackageSlice

PackageSlice is an alias for a slice of pointers to Package. This should almost always be used instead of []Package.

type PackageSlice []*Package

type PackageUpdater

type PackageUpdater interface {
    Update(o *Package, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o PackageSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type PackageUpserter

type PackageUpserter interface {
    Upsert(o *Package, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Process

Process is an object representing the database table.

type Process struct {
    ID                             int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                           string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt                      time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt                      null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Production                     null.Bool   `boil:"production" json:"production,omitempty" toml:"production" yaml:"production,omitempty"`
    Memory                         null.Int    `boil:"memory" json:"memory,omitempty" toml:"memory" yaml:"memory,omitempty"`
    Instances                      null.Int    `boil:"instances" json:"instances,omitempty" toml:"instances" yaml:"instances,omitempty"`
    FileDescriptors                null.Int    `boil:"file_descriptors" json:"file_descriptors,omitempty" toml:"file_descriptors" yaml:"file_descriptors,omitempty"`
    DiskQuota                      null.Int    `boil:"disk_quota" json:"disk_quota,omitempty" toml:"disk_quota" yaml:"disk_quota,omitempty"`
    State                          string      `boil:"state" json:"state" toml:"state" yaml:"state"`
    Version                        null.String `boil:"version" json:"version,omitempty" toml:"version" yaml:"version,omitempty"`
    Metadata                       string      `boil:"metadata" json:"metadata" toml:"metadata" yaml:"metadata"`
    DetectedBuildpack              null.String `boil:"detected_buildpack" json:"detected_buildpack,omitempty" toml:"detected_buildpack" yaml:"detected_buildpack,omitempty"`
    NotDeleted                     null.Bool   `boil:"not_deleted" json:"not_deleted,omitempty" toml:"not_deleted" yaml:"not_deleted,omitempty"`
    HealthCheckTimeout             null.Int    `boil:"health_check_timeout" json:"health_check_timeout,omitempty" toml:"health_check_timeout" yaml:"health_check_timeout,omitempty"`
    Diego                          null.Bool   `boil:"diego" json:"diego,omitempty" toml:"diego" yaml:"diego,omitempty"`
    PackageUpdatedAt               null.Time   `boil:"package_updated_at" json:"package_updated_at,omitempty" toml:"package_updated_at" yaml:"package_updated_at,omitempty"`
    AppGUID                        null.String `boil:"app_guid" json:"app_guid,omitempty" toml:"app_guid" yaml:"app_guid,omitempty"`
    Type                           null.String `boil:"type" json:"type,omitempty" toml:"type" yaml:"type,omitempty"`
    HealthCheckType                null.String `boil:"health_check_type" json:"health_check_type,omitempty" toml:"health_check_type" yaml:"health_check_type,omitempty"`
    Command                        null.String `boil:"command" json:"command,omitempty" toml:"command" yaml:"command,omitempty"`
    EnableSSH                      null.Bool   `boil:"enable_ssh" json:"enable_ssh,omitempty" toml:"enable_ssh" yaml:"enable_ssh,omitempty"`
    EncryptedDockerCredentialsJSON null.String `boil:"encrypted_docker_credentials_json" json:"encrypted_docker_credentials_json,omitempty" toml:"encrypted_docker_credentials_json" yaml:"encrypted_docker_credentials_json,omitempty"`
    DockerSalt                     null.String `boil:"docker_salt" json:"docker_salt,omitempty" toml:"docker_salt" yaml:"docker_salt,omitempty"`
    Ports                          null.String `boil:"ports" json:"ports,omitempty" toml:"ports" yaml:"ports,omitempty"`
    HealthCheckHTTPEndpoint        null.String `boil:"health_check_http_endpoint" json:"health_check_http_endpoint,omitempty" toml:"health_check_http_endpoint" yaml:"health_check_http_endpoint,omitempty"`
    HealthCheckInvocationTimeout   null.Int    `boil:"health_check_invocation_timeout" json:"health_check_invocation_timeout,omitempty" toml:"health_check_invocation_timeout" yaml:"health_check_invocation_timeout,omitempty"`
    RevisionGUID                   null.String `boil:"revision_guid" json:"revision_guid,omitempty" toml:"revision_guid" yaml:"revision_guid,omitempty"`

    R   *processR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   processL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindProcess

func FindProcess(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Process, error)

FindProcess retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ProcessAnnotation

ProcessAnnotation is an object representing the database table.

type ProcessAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *processAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   processAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindProcessAnnotation

func FindProcessAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ProcessAnnotation, error)

FindProcessAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ProcessAnnotationDeleter

type ProcessAnnotationDeleter interface {
    Delete(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ProcessAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ProcessAnnotationFinder

type ProcessAnnotationFinder interface {
    FindProcessAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ProcessAnnotation, error)
}

type ProcessAnnotationFinisher

type ProcessAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ProcessAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ProcessAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ProcessAnnotationInserter

type ProcessAnnotationInserter interface {
    Insert(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ProcessAnnotationReloader

type ProcessAnnotationReloader interface {
    Reload(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ProcessAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ProcessAnnotationSlice

ProcessAnnotationSlice is an alias for a slice of pointers to ProcessAnnotation. This should almost always be used instead of []ProcessAnnotation.

type ProcessAnnotationSlice []*ProcessAnnotation

type ProcessAnnotationUpdater

type ProcessAnnotationUpdater interface {
    Update(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ProcessAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ProcessAnnotationUpserter

type ProcessAnnotationUpserter interface {
    Upsert(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ProcessDeleter

type ProcessDeleter interface {
    Delete(o *Process, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ProcessSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ProcessFinder

type ProcessFinder interface {
    FindProcess(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Process, error)
}

type ProcessFinisher

type ProcessFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Process, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ProcessSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ProcessInserter

type ProcessInserter interface {
    Insert(o *Process, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ProcessLabel

ProcessLabel is an object representing the database table.

type ProcessLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *processLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   processLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindProcessLabel

func FindProcessLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ProcessLabel, error)

FindProcessLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ProcessLabelDeleter

type ProcessLabelDeleter interface {
    Delete(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ProcessLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ProcessLabelFinder

type ProcessLabelFinder interface {
    FindProcessLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ProcessLabel, error)
}

type ProcessLabelFinisher

type ProcessLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ProcessLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ProcessLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ProcessLabelInserter

type ProcessLabelInserter interface {
    Insert(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ProcessLabelReloader

type ProcessLabelReloader interface {
    Reload(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ProcessLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ProcessLabelSlice

ProcessLabelSlice is an alias for a slice of pointers to ProcessLabel. This should almost always be used instead of []ProcessLabel.

type ProcessLabelSlice []*ProcessLabel

type ProcessLabelUpdater

type ProcessLabelUpdater interface {
    Update(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ProcessLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ProcessLabelUpserter

type ProcessLabelUpserter interface {
    Upsert(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ProcessReloader

type ProcessReloader interface {
    Reload(o *Process, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ProcessSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ProcessSlice

ProcessSlice is an alias for a slice of pointers to Process. This should almost always be used instead of []Process.

type ProcessSlice []*Process

type ProcessUpdater

type ProcessUpdater interface {
    Update(o *Process, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ProcessSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ProcessUpserter

type ProcessUpserter interface {
    Upsert(o *Process, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type QuotaDefinition

QuotaDefinition is an object representing the database table.

type QuotaDefinition struct {
    ID                      int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                    string    `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt               time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt               null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                    string    `boil:"name" json:"name" toml:"name" yaml:"name"`
    NonBasicServicesAllowed bool      `boil:"non_basic_services_allowed" json:"non_basic_services_allowed" toml:"non_basic_services_allowed" yaml:"non_basic_services_allowed"`
    TotalServices           int       `boil:"total_services" json:"total_services" toml:"total_services" yaml:"total_services"`
    MemoryLimit             int       `boil:"memory_limit" json:"memory_limit" toml:"memory_limit" yaml:"memory_limit"`
    TotalRoutes             int       `boil:"total_routes" json:"total_routes" toml:"total_routes" yaml:"total_routes"`
    InstanceMemoryLimit     int       `boil:"instance_memory_limit" json:"instance_memory_limit" toml:"instance_memory_limit" yaml:"instance_memory_limit"`
    TotalPrivateDomains     int       `boil:"total_private_domains" json:"total_private_domains" toml:"total_private_domains" yaml:"total_private_domains"`
    AppInstanceLimit        null.Int  `boil:"app_instance_limit" json:"app_instance_limit,omitempty" toml:"app_instance_limit" yaml:"app_instance_limit,omitempty"`
    AppTaskLimit            null.Int  `boil:"app_task_limit" json:"app_task_limit,omitempty" toml:"app_task_limit" yaml:"app_task_limit,omitempty"`
    TotalServiceKeys        null.Int  `boil:"total_service_keys" json:"total_service_keys,omitempty" toml:"total_service_keys" yaml:"total_service_keys,omitempty"`
    TotalReservedRoutePorts null.Int  `boil:"total_reserved_route_ports" json:"total_reserved_route_ports,omitempty" toml:"total_reserved_route_ports" yaml:"total_reserved_route_ports,omitempty"`

    R   *quotaDefinitionR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   quotaDefinitionL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindQuotaDefinition

func FindQuotaDefinition(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*QuotaDefinition, error)

FindQuotaDefinition retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type QuotaDefinitionDeleter

type QuotaDefinitionDeleter interface {
    Delete(o *QuotaDefinition, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o QuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type QuotaDefinitionFinder

type QuotaDefinitionFinder interface {
    FindQuotaDefinition(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*QuotaDefinition, error)
}

type QuotaDefinitionFinisher

type QuotaDefinitionFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*QuotaDefinition, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (QuotaDefinitionSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type QuotaDefinitionInserter

type QuotaDefinitionInserter interface {
    Insert(o *QuotaDefinition, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type QuotaDefinitionReloader

type QuotaDefinitionReloader interface {
    Reload(o *QuotaDefinition, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *QuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type QuotaDefinitionSlice

QuotaDefinitionSlice is an alias for a slice of pointers to QuotaDefinition. This should almost always be used instead of []QuotaDefinition.

type QuotaDefinitionSlice []*QuotaDefinition

type QuotaDefinitionUpdater

type QuotaDefinitionUpdater interface {
    Update(o *QuotaDefinition, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o QuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type QuotaDefinitionUpserter

type QuotaDefinitionUpserter interface {
    Upsert(o *QuotaDefinition, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RequestCount

RequestCount is an object representing the database table.

type RequestCount struct {
    ID         int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    UserGUID   null.String `boil:"user_guid" json:"user_guid,omitempty" toml:"user_guid" yaml:"user_guid,omitempty"`
    Count      null.Int    `boil:"count" json:"count,omitempty" toml:"count" yaml:"count,omitempty"`
    ValidUntil null.Time   `boil:"valid_until" json:"valid_until,omitempty" toml:"valid_until" yaml:"valid_until,omitempty"`

    R   *requestCountR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   requestCountL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRequestCount

func FindRequestCount(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RequestCount, error)

FindRequestCount retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RequestCountDeleter

type RequestCountDeleter interface {
    Delete(o *RequestCount, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RequestCountSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RequestCountFinder

type RequestCountFinder interface {
    FindRequestCount(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RequestCount, error)
}

type RequestCountFinisher

type RequestCountFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RequestCount, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RequestCountSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RequestCountInserter

type RequestCountInserter interface {
    Insert(o *RequestCount, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RequestCountReloader

type RequestCountReloader interface {
    Reload(o *RequestCount, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RequestCountSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RequestCountSlice

RequestCountSlice is an alias for a slice of pointers to RequestCount. This should almost always be used instead of []RequestCount.

type RequestCountSlice []*RequestCount

type RequestCountUpdater

type RequestCountUpdater interface {
    Update(o *RequestCount, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RequestCountSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RequestCountUpserter

type RequestCountUpserter interface {
    Upsert(o *RequestCount, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Revision

Revision is an object representing the database table.

type Revision struct {
    ID                            int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                          string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt                     time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt                     null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    AppGUID                       null.String `boil:"app_guid" json:"app_guid,omitempty" toml:"app_guid" yaml:"app_guid,omitempty"`
    Version                       null.Int    `boil:"version" json:"version,omitempty" toml:"version" yaml:"version,omitempty"`
    DropletGUID                   null.String `boil:"droplet_guid" json:"droplet_guid,omitempty" toml:"droplet_guid" yaml:"droplet_guid,omitempty"`
    EncryptedEnvironmentVariables null.String `boil:"encrypted_environment_variables" json:"encrypted_environment_variables,omitempty" toml:"encrypted_environment_variables" yaml:"encrypted_environment_variables,omitempty"`
    Salt                          null.String `boil:"salt" json:"salt,omitempty" toml:"salt" yaml:"salt,omitempty"`
    EncryptionKeyLabel            null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations          int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`
    Description                   string      `boil:"description" json:"description" toml:"description" yaml:"description"`

    R   *revisionR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   revisionL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRevision

func FindRevision(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Revision, error)

FindRevision retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RevisionAnnotation

RevisionAnnotation is an object representing the database table.

type RevisionAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *revisionAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   revisionAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRevisionAnnotation

func FindRevisionAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RevisionAnnotation, error)

FindRevisionAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RevisionAnnotationDeleter

type RevisionAnnotationDeleter interface {
    Delete(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RevisionAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RevisionAnnotationFinder

type RevisionAnnotationFinder interface {
    FindRevisionAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RevisionAnnotation, error)
}

type RevisionAnnotationFinisher

type RevisionAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RevisionAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RevisionAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RevisionAnnotationInserter

type RevisionAnnotationInserter interface {
    Insert(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RevisionAnnotationReloader

type RevisionAnnotationReloader interface {
    Reload(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RevisionAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RevisionAnnotationSlice

RevisionAnnotationSlice is an alias for a slice of pointers to RevisionAnnotation. This should almost always be used instead of []RevisionAnnotation.

type RevisionAnnotationSlice []*RevisionAnnotation

type RevisionAnnotationUpdater

type RevisionAnnotationUpdater interface {
    Update(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RevisionAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RevisionAnnotationUpserter

type RevisionAnnotationUpserter interface {
    Upsert(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RevisionDeleter

type RevisionDeleter interface {
    Delete(o *Revision, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RevisionSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RevisionFinder

type RevisionFinder interface {
    FindRevision(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Revision, error)
}

type RevisionFinisher

type RevisionFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Revision, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RevisionSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RevisionInserter

type RevisionInserter interface {
    Insert(o *Revision, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RevisionLabel

RevisionLabel is an object representing the database table.

type RevisionLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *revisionLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   revisionLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRevisionLabel

func FindRevisionLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RevisionLabel, error)

FindRevisionLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RevisionLabelDeleter

type RevisionLabelDeleter interface {
    Delete(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RevisionLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RevisionLabelFinder

type RevisionLabelFinder interface {
    FindRevisionLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RevisionLabel, error)
}

type RevisionLabelFinisher

type RevisionLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RevisionLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RevisionLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RevisionLabelInserter

type RevisionLabelInserter interface {
    Insert(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RevisionLabelReloader

type RevisionLabelReloader interface {
    Reload(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RevisionLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RevisionLabelSlice

RevisionLabelSlice is an alias for a slice of pointers to RevisionLabel. This should almost always be used instead of []RevisionLabel.

type RevisionLabelSlice []*RevisionLabel

type RevisionLabelUpdater

type RevisionLabelUpdater interface {
    Update(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RevisionLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RevisionLabelUpserter

type RevisionLabelUpserter interface {
    Upsert(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RevisionProcessCommand

RevisionProcessCommand is an object representing the database table.

type RevisionProcessCommand struct {
    ID             int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID           string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt      time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt      null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    RevisionGUID   string      `boil:"revision_guid" json:"revision_guid" toml:"revision_guid" yaml:"revision_guid"`
    ProcessType    string      `boil:"process_type" json:"process_type" toml:"process_type" yaml:"process_type"`
    ProcessCommand null.String `boil:"process_command" json:"process_command,omitempty" toml:"process_command" yaml:"process_command,omitempty"`

    R   *revisionProcessCommandR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   revisionProcessCommandL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRevisionProcessCommand

func FindRevisionProcessCommand(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RevisionProcessCommand, error)

FindRevisionProcessCommand retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RevisionProcessCommandDeleter

type RevisionProcessCommandDeleter interface {
    Delete(o *RevisionProcessCommand, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RevisionProcessCommandSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RevisionProcessCommandFinder

type RevisionProcessCommandFinder interface {
    FindRevisionProcessCommand(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RevisionProcessCommand, error)
}

type RevisionProcessCommandFinisher

type RevisionProcessCommandFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RevisionProcessCommand, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RevisionProcessCommandSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RevisionProcessCommandInserter

type RevisionProcessCommandInserter interface {
    Insert(o *RevisionProcessCommand, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RevisionProcessCommandReloader

type RevisionProcessCommandReloader interface {
    Reload(o *RevisionProcessCommand, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RevisionProcessCommandSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RevisionProcessCommandSlice

RevisionProcessCommandSlice is an alias for a slice of pointers to RevisionProcessCommand. This should almost always be used instead of []RevisionProcessCommand.

type RevisionProcessCommandSlice []*RevisionProcessCommand

type RevisionProcessCommandUpdater

type RevisionProcessCommandUpdater interface {
    Update(o *RevisionProcessCommand, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RevisionProcessCommandSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RevisionProcessCommandUpserter

type RevisionProcessCommandUpserter interface {
    Upsert(o *RevisionProcessCommand, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RevisionReloader

type RevisionReloader interface {
    Reload(o *Revision, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RevisionSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RevisionSidecar

RevisionSidecar is an object representing the database table.

type RevisionSidecar struct {
    ID           int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string    `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name         string    `boil:"name" json:"name" toml:"name" yaml:"name"`
    Command      string    `boil:"command" json:"command" toml:"command" yaml:"command"`
    RevisionGUID string    `boil:"revision_guid" json:"revision_guid" toml:"revision_guid" yaml:"revision_guid"`
    Memory       null.Int  `boil:"memory" json:"memory,omitempty" toml:"memory" yaml:"memory,omitempty"`

    R   *revisionSidecarR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   revisionSidecarL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRevisionSidecar

func FindRevisionSidecar(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RevisionSidecar, error)

FindRevisionSidecar retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RevisionSidecarDeleter

type RevisionSidecarDeleter interface {
    Delete(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RevisionSidecarSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RevisionSidecarFinder

type RevisionSidecarFinder interface {
    FindRevisionSidecar(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RevisionSidecar, error)
}

type RevisionSidecarFinisher

type RevisionSidecarFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RevisionSidecar, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RevisionSidecarSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RevisionSidecarInserter

type RevisionSidecarInserter interface {
    Insert(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RevisionSidecarProcessType

RevisionSidecarProcessType is an object representing the database table.

type RevisionSidecarProcessType struct {
    ID                  int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                string    `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt           time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt           null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Type                string    `boil:"type" json:"type" toml:"type" yaml:"type"`
    RevisionSidecarGUID string    `boil:"revision_sidecar_guid" json:"revision_sidecar_guid" toml:"revision_sidecar_guid" yaml:"revision_sidecar_guid"`

    R   *revisionSidecarProcessTypeR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   revisionSidecarProcessTypeL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRevisionSidecarProcessType

func FindRevisionSidecarProcessType(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RevisionSidecarProcessType, error)

FindRevisionSidecarProcessType retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RevisionSidecarProcessTypeDeleter

type RevisionSidecarProcessTypeDeleter interface {
    Delete(o *RevisionSidecarProcessType, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RevisionSidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RevisionSidecarProcessTypeFinder

type RevisionSidecarProcessTypeFinder interface {
    FindRevisionSidecarProcessType(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RevisionSidecarProcessType, error)
}

type RevisionSidecarProcessTypeFinisher

type RevisionSidecarProcessTypeFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RevisionSidecarProcessType, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RevisionSidecarProcessTypeSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RevisionSidecarProcessTypeInserter

type RevisionSidecarProcessTypeInserter interface {
    Insert(o *RevisionSidecarProcessType, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RevisionSidecarProcessTypeReloader

type RevisionSidecarProcessTypeReloader interface {
    Reload(o *RevisionSidecarProcessType, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RevisionSidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RevisionSidecarProcessTypeSlice

RevisionSidecarProcessTypeSlice is an alias for a slice of pointers to RevisionSidecarProcessType. This should almost always be used instead of []RevisionSidecarProcessType.

type RevisionSidecarProcessTypeSlice []*RevisionSidecarProcessType

type RevisionSidecarProcessTypeUpdater

type RevisionSidecarProcessTypeUpdater interface {
    Update(o *RevisionSidecarProcessType, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RevisionSidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RevisionSidecarProcessTypeUpserter

type RevisionSidecarProcessTypeUpserter interface {
    Upsert(o *RevisionSidecarProcessType, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RevisionSidecarReloader

type RevisionSidecarReloader interface {
    Reload(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RevisionSidecarSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RevisionSidecarSlice

RevisionSidecarSlice is an alias for a slice of pointers to RevisionSidecar. This should almost always be used instead of []RevisionSidecar.

type RevisionSidecarSlice []*RevisionSidecar

type RevisionSidecarUpdater

type RevisionSidecarUpdater interface {
    Update(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RevisionSidecarSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RevisionSidecarUpserter

type RevisionSidecarUpserter interface {
    Upsert(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RevisionSlice

RevisionSlice is an alias for a slice of pointers to Revision. This should almost always be used instead of []Revision.

type RevisionSlice []*Revision

type RevisionUpdater

type RevisionUpdater interface {
    Update(o *Revision, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RevisionSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RevisionUpserter

type RevisionUpserter interface {
    Upsert(o *Revision, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Route

Route is an object representing the database table.

type Route struct {
    ID        int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID      string    `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Host      string    `boil:"host" json:"host" toml:"host" yaml:"host"`
    DomainID  int       `boil:"domain_id" json:"domain_id" toml:"domain_id" yaml:"domain_id"`
    SpaceID   int       `boil:"space_id" json:"space_id" toml:"space_id" yaml:"space_id"`
    Path      string    `boil:"path" json:"path" toml:"path" yaml:"path"`
    Port      int       `boil:"port" json:"port" toml:"port" yaml:"port"`
    VipOffset null.Int  `boil:"vip_offset" json:"vip_offset,omitempty" toml:"vip_offset" yaml:"vip_offset,omitempty"`

    R   *routeR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   routeL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRoute

func FindRoute(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Route, error)

FindRoute retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RouteAnnotation

RouteAnnotation is an object representing the database table.

type RouteAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *routeAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   routeAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRouteAnnotation

func FindRouteAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteAnnotation, error)

FindRouteAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RouteAnnotationDeleter

type RouteAnnotationDeleter interface {
    Delete(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RouteAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RouteAnnotationFinder

type RouteAnnotationFinder interface {
    FindRouteAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteAnnotation, error)
}

type RouteAnnotationFinisher

type RouteAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RouteAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RouteAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RouteAnnotationInserter

type RouteAnnotationInserter interface {
    Insert(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RouteAnnotationReloader

type RouteAnnotationReloader interface {
    Reload(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RouteAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RouteAnnotationSlice

RouteAnnotationSlice is an alias for a slice of pointers to RouteAnnotation. This should almost always be used instead of []RouteAnnotation.

type RouteAnnotationSlice []*RouteAnnotation

type RouteAnnotationUpdater

type RouteAnnotationUpdater interface {
    Update(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RouteAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RouteAnnotationUpserter

type RouteAnnotationUpserter interface {
    Upsert(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RouteBinding

RouteBinding is an object representing the database table.

type RouteBinding struct {
    ID                int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID              string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt         time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt         null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    RouteID           null.Int    `boil:"route_id" json:"route_id,omitempty" toml:"route_id" yaml:"route_id,omitempty"`
    ServiceInstanceID null.Int    `boil:"service_instance_id" json:"service_instance_id,omitempty" toml:"service_instance_id" yaml:"service_instance_id,omitempty"`
    RouteServiceURL   null.String `boil:"route_service_url" json:"route_service_url,omitempty" toml:"route_service_url" yaml:"route_service_url,omitempty"`

    R   *routeBindingR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   routeBindingL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRouteBinding

func FindRouteBinding(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteBinding, error)

FindRouteBinding retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RouteBindingAnnotation

RouteBindingAnnotation is an object representing the database table.

type RouteBindingAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *routeBindingAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   routeBindingAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRouteBindingAnnotation

func FindRouteBindingAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteBindingAnnotation, error)

FindRouteBindingAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RouteBindingAnnotationDeleter

type RouteBindingAnnotationDeleter interface {
    Delete(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RouteBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RouteBindingAnnotationFinder

type RouteBindingAnnotationFinder interface {
    FindRouteBindingAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteBindingAnnotation, error)
}

type RouteBindingAnnotationFinisher

type RouteBindingAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RouteBindingAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RouteBindingAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RouteBindingAnnotationInserter

type RouteBindingAnnotationInserter interface {
    Insert(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RouteBindingAnnotationReloader

type RouteBindingAnnotationReloader interface {
    Reload(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RouteBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RouteBindingAnnotationSlice

RouteBindingAnnotationSlice is an alias for a slice of pointers to RouteBindingAnnotation. This should almost always be used instead of []RouteBindingAnnotation.

type RouteBindingAnnotationSlice []*RouteBindingAnnotation

type RouteBindingAnnotationUpdater

type RouteBindingAnnotationUpdater interface {
    Update(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RouteBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RouteBindingAnnotationUpserter

type RouteBindingAnnotationUpserter interface {
    Upsert(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RouteBindingDeleter

type RouteBindingDeleter interface {
    Delete(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RouteBindingSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RouteBindingFinder

type RouteBindingFinder interface {
    FindRouteBinding(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteBinding, error)
}

type RouteBindingFinisher

type RouteBindingFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RouteBinding, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RouteBindingSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RouteBindingInserter

type RouteBindingInserter interface {
    Insert(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RouteBindingLabel

RouteBindingLabel is an object representing the database table.

type RouteBindingLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *routeBindingLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   routeBindingLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRouteBindingLabel

func FindRouteBindingLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteBindingLabel, error)

FindRouteBindingLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RouteBindingLabelDeleter

type RouteBindingLabelDeleter interface {
    Delete(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RouteBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RouteBindingLabelFinder

type RouteBindingLabelFinder interface {
    FindRouteBindingLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteBindingLabel, error)
}

type RouteBindingLabelFinisher

type RouteBindingLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RouteBindingLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RouteBindingLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RouteBindingLabelInserter

type RouteBindingLabelInserter interface {
    Insert(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RouteBindingLabelReloader

type RouteBindingLabelReloader interface {
    Reload(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RouteBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RouteBindingLabelSlice

RouteBindingLabelSlice is an alias for a slice of pointers to RouteBindingLabel. This should almost always be used instead of []RouteBindingLabel.

type RouteBindingLabelSlice []*RouteBindingLabel

type RouteBindingLabelUpdater

type RouteBindingLabelUpdater interface {
    Update(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RouteBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RouteBindingLabelUpserter

type RouteBindingLabelUpserter interface {
    Upsert(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RouteBindingOperation

RouteBindingOperation is an object representing the database table.

type RouteBindingOperation struct {
    ID                      int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    CreatedAt               time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt               null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    RouteBindingID          null.Int    `boil:"route_binding_id" json:"route_binding_id,omitempty" toml:"route_binding_id" yaml:"route_binding_id,omitempty"`
    State                   string      `boil:"state" json:"state" toml:"state" yaml:"state"`
    Type                    string      `boil:"type" json:"type" toml:"type" yaml:"type"`
    Description             null.String `boil:"description" json:"description,omitempty" toml:"description" yaml:"description,omitempty"`
    BrokerProvidedOperation null.String `boil:"broker_provided_operation" json:"broker_provided_operation,omitempty" toml:"broker_provided_operation" yaml:"broker_provided_operation,omitempty"`

    R   *routeBindingOperationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   routeBindingOperationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRouteBindingOperation

func FindRouteBindingOperation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteBindingOperation, error)

FindRouteBindingOperation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RouteBindingOperationDeleter

type RouteBindingOperationDeleter interface {
    Delete(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RouteBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RouteBindingOperationFinder

type RouteBindingOperationFinder interface {
    FindRouteBindingOperation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteBindingOperation, error)
}

type RouteBindingOperationFinisher

type RouteBindingOperationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RouteBindingOperation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RouteBindingOperationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RouteBindingOperationInserter

type RouteBindingOperationInserter interface {
    Insert(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RouteBindingOperationReloader

type RouteBindingOperationReloader interface {
    Reload(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RouteBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RouteBindingOperationSlice

RouteBindingOperationSlice is an alias for a slice of pointers to RouteBindingOperation. This should almost always be used instead of []RouteBindingOperation.

type RouteBindingOperationSlice []*RouteBindingOperation

type RouteBindingOperationUpdater

type RouteBindingOperationUpdater interface {
    Update(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RouteBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RouteBindingOperationUpserter

type RouteBindingOperationUpserter interface {
    Upsert(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RouteBindingReloader

type RouteBindingReloader interface {
    Reload(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RouteBindingSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RouteBindingSlice

RouteBindingSlice is an alias for a slice of pointers to RouteBinding. This should almost always be used instead of []RouteBinding.

type RouteBindingSlice []*RouteBinding

type RouteBindingUpdater

type RouteBindingUpdater interface {
    Update(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RouteBindingSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RouteBindingUpserter

type RouteBindingUpserter interface {
    Upsert(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RouteDeleter

type RouteDeleter interface {
    Delete(o *Route, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RouteSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RouteFinder

type RouteFinder interface {
    FindRoute(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Route, error)
}

type RouteFinisher

type RouteFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Route, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RouteSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RouteInserter

type RouteInserter interface {
    Insert(o *Route, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RouteLabel

RouteLabel is an object representing the database table.

type RouteLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *routeLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   routeLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRouteLabel

func FindRouteLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteLabel, error)

FindRouteLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RouteLabelDeleter

type RouteLabelDeleter interface {
    Delete(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RouteLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RouteLabelFinder

type RouteLabelFinder interface {
    FindRouteLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteLabel, error)
}

type RouteLabelFinisher

type RouteLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RouteLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RouteLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RouteLabelInserter

type RouteLabelInserter interface {
    Insert(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RouteLabelReloader

type RouteLabelReloader interface {
    Reload(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RouteLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RouteLabelSlice

RouteLabelSlice is an alias for a slice of pointers to RouteLabel. This should almost always be used instead of []RouteLabel.

type RouteLabelSlice []*RouteLabel

type RouteLabelUpdater

type RouteLabelUpdater interface {
    Update(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RouteLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RouteLabelUpserter

type RouteLabelUpserter interface {
    Upsert(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RouteMapping

RouteMapping is an object representing the database table.

type RouteMapping struct {
    ID          int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    CreatedAt   time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt   null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    AppPort     null.Int    `boil:"app_port" json:"app_port,omitempty" toml:"app_port" yaml:"app_port,omitempty"`
    GUID        string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    AppGUID     string      `boil:"app_guid" json:"app_guid" toml:"app_guid" yaml:"app_guid"`
    RouteGUID   string      `boil:"route_guid" json:"route_guid" toml:"route_guid" yaml:"route_guid"`
    ProcessType null.String `boil:"process_type" json:"process_type,omitempty" toml:"process_type" yaml:"process_type,omitempty"`
    Weight      null.Int    `boil:"weight" json:"weight,omitempty" toml:"weight" yaml:"weight,omitempty"`

    R   *routeMappingR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   routeMappingL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindRouteMapping

func FindRouteMapping(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteMapping, error)

FindRouteMapping retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type RouteMappingDeleter

type RouteMappingDeleter interface {
    Delete(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o RouteMappingSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type RouteMappingFinder

type RouteMappingFinder interface {
    FindRouteMapping(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*RouteMapping, error)
}

type RouteMappingFinisher

type RouteMappingFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*RouteMapping, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (RouteMappingSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type RouteMappingInserter

type RouteMappingInserter interface {
    Insert(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type RouteMappingReloader

type RouteMappingReloader interface {
    Reload(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RouteMappingSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RouteMappingSlice

RouteMappingSlice is an alias for a slice of pointers to RouteMapping. This should almost always be used instead of []RouteMapping.

type RouteMappingSlice []*RouteMapping

type RouteMappingUpdater

type RouteMappingUpdater interface {
    Update(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RouteMappingSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RouteMappingUpserter

type RouteMappingUpserter interface {
    Upsert(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type RouteReloader

type RouteReloader interface {
    Reload(o *Route, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *RouteSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type RouteSlice

RouteSlice is an alias for a slice of pointers to Route. This should almost always be used instead of []Route.

type RouteSlice []*Route

type RouteUpdater

type RouteUpdater interface {
    Update(o *Route, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o RouteSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type RouteUpserter

type RouteUpserter interface {
    Upsert(o *Route, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type SchemaMigration

SchemaMigration is an object representing the database table.

type SchemaMigration struct {
    Filename string `boil:"filename" json:"filename" toml:"filename" yaml:"filename"`

    R   *schemaMigrationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   schemaMigrationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSchemaMigration

func FindSchemaMigration(ctx context.Context, exec boil.ContextExecutor, filename string, selectCols ...string) (*SchemaMigration, error)

FindSchemaMigration retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SchemaMigrationDeleter

type SchemaMigrationDeleter interface {
    Delete(o *SchemaMigration, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SchemaMigrationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SchemaMigrationFinder

type SchemaMigrationFinder interface {
    FindSchemaMigration(ctx context.Context, exec boil.ContextExecutor, filename string, selectCols ...string) (*SchemaMigration, error)
}

type SchemaMigrationFinisher

type SchemaMigrationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*SchemaMigration, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SchemaMigrationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SchemaMigrationInserter

type SchemaMigrationInserter interface {
    Insert(o *SchemaMigration, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SchemaMigrationReloader

type SchemaMigrationReloader interface {
    Reload(o *SchemaMigration, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SchemaMigrationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SchemaMigrationSlice

SchemaMigrationSlice is an alias for a slice of pointers to SchemaMigration. This should almost always be used instead of []SchemaMigration.

type SchemaMigrationSlice []*SchemaMigration

type SchemaMigrationUpdater

type SchemaMigrationUpdater interface {
    Update(o *SchemaMigration, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SchemaMigrationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SchemaMigrationUpserter

type SchemaMigrationUpserter interface {
    Upsert(o *SchemaMigration, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type SecurityGroup

SecurityGroup is an object representing the database table.

type SecurityGroup struct {
    ID             int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID           string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt      time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt      null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name           string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    Rules          null.String `boil:"rules" json:"rules,omitempty" toml:"rules" yaml:"rules,omitempty"`
    StagingDefault null.Bool   `boil:"staging_default" json:"staging_default,omitempty" toml:"staging_default" yaml:"staging_default,omitempty"`
    RunningDefault null.Bool   `boil:"running_default" json:"running_default,omitempty" toml:"running_default" yaml:"running_default,omitempty"`

    R   *securityGroupR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   securityGroupL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSecurityGroup

func FindSecurityGroup(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*SecurityGroup, error)

FindSecurityGroup retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SecurityGroupDeleter

type SecurityGroupDeleter interface {
    Delete(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SecurityGroupSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SecurityGroupFinder

type SecurityGroupFinder interface {
    FindSecurityGroup(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*SecurityGroup, error)
}

type SecurityGroupFinisher

type SecurityGroupFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*SecurityGroup, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SecurityGroupSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SecurityGroupInserter

type SecurityGroupInserter interface {
    Insert(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SecurityGroupReloader

type SecurityGroupReloader interface {
    Reload(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SecurityGroupSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SecurityGroupSlice

SecurityGroupSlice is an alias for a slice of pointers to SecurityGroup. This should almost always be used instead of []SecurityGroup.

type SecurityGroupSlice []*SecurityGroup

type SecurityGroupUpdater

type SecurityGroupUpdater interface {
    Update(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SecurityGroupSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SecurityGroupUpserter

type SecurityGroupUpserter interface {
    Upsert(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type SecurityGroupsSpace

SecurityGroupsSpace is an object representing the database table.

type SecurityGroupsSpace struct {
    SecurityGroupID        int `boil:"security_group_id" json:"security_group_id" toml:"security_group_id" yaml:"security_group_id"`
    SpaceID                int `boil:"space_id" json:"space_id" toml:"space_id" yaml:"space_id"`
    SecurityGroupsSpacesPK int `boil:"security_groups_spaces_pk" json:"security_groups_spaces_pk" toml:"security_groups_spaces_pk" yaml:"security_groups_spaces_pk"`

    R   *securityGroupsSpaceR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   securityGroupsSpaceL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSecurityGroupsSpace

func FindSecurityGroupsSpace(ctx context.Context, exec boil.ContextExecutor, securityGroupsSpacesPK int, selectCols ...string) (*SecurityGroupsSpace, error)

FindSecurityGroupsSpace retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SecurityGroupsSpaceDeleter

type SecurityGroupsSpaceDeleter interface {
    Delete(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SecurityGroupsSpaceFinder

type SecurityGroupsSpaceFinder interface {
    FindSecurityGroupsSpace(ctx context.Context, exec boil.ContextExecutor, securityGroupsSpacesPK int, selectCols ...string) (*SecurityGroupsSpace, error)
}

type SecurityGroupsSpaceFinisher

type SecurityGroupsSpaceFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*SecurityGroupsSpace, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SecurityGroupsSpaceSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SecurityGroupsSpaceInserter

type SecurityGroupsSpaceInserter interface {
    Insert(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SecurityGroupsSpaceReloader

type SecurityGroupsSpaceReloader interface {
    Reload(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SecurityGroupsSpaceSlice

SecurityGroupsSpaceSlice is an alias for a slice of pointers to SecurityGroupsSpace. This should almost always be used instead of []SecurityGroupsSpace.

type SecurityGroupsSpaceSlice []*SecurityGroupsSpace

type SecurityGroupsSpaceUpdater

type SecurityGroupsSpaceUpdater interface {
    Update(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SecurityGroupsSpaceUpserter

type SecurityGroupsSpaceUpserter interface {
    Upsert(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Service

Service is an object representing the database table.

type Service struct {
    ID                   int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                 string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt            time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt            null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Label                string      `boil:"label" json:"label" toml:"label" yaml:"label"`
    Description          string      `boil:"description" json:"description" toml:"description" yaml:"description"`
    InfoURL              null.String `boil:"info_url" json:"info_url,omitempty" toml:"info_url" yaml:"info_url,omitempty"`
    Acls                 null.String `boil:"acls" json:"acls,omitempty" toml:"acls" yaml:"acls,omitempty"`
    Timeout              null.Int    `boil:"timeout" json:"timeout,omitempty" toml:"timeout" yaml:"timeout,omitempty"`
    Active               null.Bool   `boil:"active" json:"active,omitempty" toml:"active" yaml:"active,omitempty"`
    Extra                null.String `boil:"extra" json:"extra,omitempty" toml:"extra" yaml:"extra,omitempty"`
    UniqueID             null.String `boil:"unique_id" json:"unique_id,omitempty" toml:"unique_id" yaml:"unique_id,omitempty"`
    Bindable             bool        `boil:"bindable" json:"bindable" toml:"bindable" yaml:"bindable"`
    Tags                 null.String `boil:"tags" json:"tags,omitempty" toml:"tags" yaml:"tags,omitempty"`
    DocumentationURL     null.String `boil:"documentation_url" json:"documentation_url,omitempty" toml:"documentation_url" yaml:"documentation_url,omitempty"`
    ServiceBrokerID      null.Int    `boil:"service_broker_id" json:"service_broker_id,omitempty" toml:"service_broker_id" yaml:"service_broker_id,omitempty"`
    LongDescription      null.String `boil:"long_description" json:"long_description,omitempty" toml:"long_description" yaml:"long_description,omitempty"`
    Requires             null.String `boil:"requires" json:"requires,omitempty" toml:"requires" yaml:"requires,omitempty"`
    Purging              bool        `boil:"purging" json:"purging" toml:"purging" yaml:"purging"`
    PlanUpdateable       null.Bool   `boil:"plan_updateable" json:"plan_updateable,omitempty" toml:"plan_updateable" yaml:"plan_updateable,omitempty"`
    BindingsRetrievable  bool        `boil:"bindings_retrievable" json:"bindings_retrievable" toml:"bindings_retrievable" yaml:"bindings_retrievable"`
    InstancesRetrievable bool        `boil:"instances_retrievable" json:"instances_retrievable" toml:"instances_retrievable" yaml:"instances_retrievable"`
    AllowContextUpdates  bool        `boil:"allow_context_updates" json:"allow_context_updates" toml:"allow_context_updates" yaml:"allow_context_updates"`

    R   *serviceR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindService

func FindService(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Service, error)

FindService retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceBinding

ServiceBinding is an object representing the database table.

type ServiceBinding struct {
    ID                   int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                 string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt            time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt            null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Credentials          string      `boil:"credentials" json:"credentials" toml:"credentials" yaml:"credentials"`
    Salt                 null.String `boil:"salt" json:"salt,omitempty" toml:"salt" yaml:"salt,omitempty"`
    SyslogDrainURL       null.String `boil:"syslog_drain_url" json:"syslog_drain_url,omitempty" toml:"syslog_drain_url" yaml:"syslog_drain_url,omitempty"`
    VolumeMounts         null.String `boil:"volume_mounts" json:"volume_mounts,omitempty" toml:"volume_mounts" yaml:"volume_mounts,omitempty"`
    VolumeMountsSalt     null.String `boil:"volume_mounts_salt" json:"volume_mounts_salt,omitempty" toml:"volume_mounts_salt" yaml:"volume_mounts_salt,omitempty"`
    AppGUID              string      `boil:"app_guid" json:"app_guid" toml:"app_guid" yaml:"app_guid"`
    ServiceInstanceGUID  string      `boil:"service_instance_guid" json:"service_instance_guid" toml:"service_instance_guid" yaml:"service_instance_guid"`
    Type                 null.String `boil:"type" json:"type,omitempty" toml:"type" yaml:"type,omitempty"`
    Name                 null.String `boil:"name" json:"name,omitempty" toml:"name" yaml:"name,omitempty"`
    EncryptionKeyLabel   null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`

    R   *serviceBindingR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceBindingL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceBinding

func FindServiceBinding(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBinding, error)

FindServiceBinding retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceBindingAnnotation

ServiceBindingAnnotation is an object representing the database table.

type ServiceBindingAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceBindingAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceBindingAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceBindingAnnotation

func FindServiceBindingAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBindingAnnotation, error)

FindServiceBindingAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceBindingAnnotationDeleter

type ServiceBindingAnnotationDeleter interface {
    Delete(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceBindingAnnotationFinder

type ServiceBindingAnnotationFinder interface {
    FindServiceBindingAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBindingAnnotation, error)
}

type ServiceBindingAnnotationFinisher

type ServiceBindingAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBindingAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceBindingAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceBindingAnnotationInserter

type ServiceBindingAnnotationInserter interface {
    Insert(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceBindingAnnotationReloader

type ServiceBindingAnnotationReloader interface {
    Reload(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceBindingAnnotationSlice

ServiceBindingAnnotationSlice is an alias for a slice of pointers to ServiceBindingAnnotation. This should almost always be used instead of []ServiceBindingAnnotation.

type ServiceBindingAnnotationSlice []*ServiceBindingAnnotation

type ServiceBindingAnnotationUpdater

type ServiceBindingAnnotationUpdater interface {
    Update(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceBindingAnnotationUpserter

type ServiceBindingAnnotationUpserter interface {
    Upsert(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceBindingDeleter

type ServiceBindingDeleter interface {
    Delete(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceBindingSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceBindingFinder

type ServiceBindingFinder interface {
    FindServiceBinding(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBinding, error)
}

type ServiceBindingFinisher

type ServiceBindingFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBinding, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceBindingSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceBindingInserter

type ServiceBindingInserter interface {
    Insert(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceBindingLabel

ServiceBindingLabel is an object representing the database table.

type ServiceBindingLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceBindingLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceBindingLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceBindingLabel

func FindServiceBindingLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBindingLabel, error)

FindServiceBindingLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceBindingLabelDeleter

type ServiceBindingLabelDeleter interface {
    Delete(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceBindingLabelFinder

type ServiceBindingLabelFinder interface {
    FindServiceBindingLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBindingLabel, error)
}

type ServiceBindingLabelFinisher

type ServiceBindingLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBindingLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceBindingLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceBindingLabelInserter

type ServiceBindingLabelInserter interface {
    Insert(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceBindingLabelReloader

type ServiceBindingLabelReloader interface {
    Reload(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceBindingLabelSlice

ServiceBindingLabelSlice is an alias for a slice of pointers to ServiceBindingLabel. This should almost always be used instead of []ServiceBindingLabel.

type ServiceBindingLabelSlice []*ServiceBindingLabel

type ServiceBindingLabelUpdater

type ServiceBindingLabelUpdater interface {
    Update(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceBindingLabelUpserter

type ServiceBindingLabelUpserter interface {
    Upsert(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceBindingOperation

ServiceBindingOperation is an object representing the database table.

type ServiceBindingOperation struct {
    ID                      int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    CreatedAt               time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt               null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ServiceBindingID        null.Int    `boil:"service_binding_id" json:"service_binding_id,omitempty" toml:"service_binding_id" yaml:"service_binding_id,omitempty"`
    State                   string      `boil:"state" json:"state" toml:"state" yaml:"state"`
    Type                    string      `boil:"type" json:"type" toml:"type" yaml:"type"`
    Description             null.String `boil:"description" json:"description,omitempty" toml:"description" yaml:"description,omitempty"`
    BrokerProvidedOperation null.String `boil:"broker_provided_operation" json:"broker_provided_operation,omitempty" toml:"broker_provided_operation" yaml:"broker_provided_operation,omitempty"`

    R   *serviceBindingOperationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceBindingOperationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceBindingOperation

func FindServiceBindingOperation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBindingOperation, error)

FindServiceBindingOperation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceBindingOperationDeleter

type ServiceBindingOperationDeleter interface {
    Delete(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceBindingOperationFinder

type ServiceBindingOperationFinder interface {
    FindServiceBindingOperation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBindingOperation, error)
}

type ServiceBindingOperationFinisher

type ServiceBindingOperationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBindingOperation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceBindingOperationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceBindingOperationInserter

type ServiceBindingOperationInserter interface {
    Insert(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceBindingOperationReloader

type ServiceBindingOperationReloader interface {
    Reload(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceBindingOperationSlice

ServiceBindingOperationSlice is an alias for a slice of pointers to ServiceBindingOperation. This should almost always be used instead of []ServiceBindingOperation.

type ServiceBindingOperationSlice []*ServiceBindingOperation

type ServiceBindingOperationUpdater

type ServiceBindingOperationUpdater interface {
    Update(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceBindingOperationUpserter

type ServiceBindingOperationUpserter interface {
    Upsert(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceBindingReloader

type ServiceBindingReloader interface {
    Reload(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceBindingSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceBindingSlice

ServiceBindingSlice is an alias for a slice of pointers to ServiceBinding. This should almost always be used instead of []ServiceBinding.

type ServiceBindingSlice []*ServiceBinding

type ServiceBindingUpdater

type ServiceBindingUpdater interface {
    Update(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceBindingSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceBindingUpserter

type ServiceBindingUpserter interface {
    Upsert(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceBroker

ServiceBroker is an object representing the database table.

type ServiceBroker struct {
    ID                   int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                 string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt            time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt            null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                 string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    BrokerURL            string      `boil:"broker_url" json:"broker_url" toml:"broker_url" yaml:"broker_url"`
    AuthPassword         string      `boil:"auth_password" json:"auth_password" toml:"auth_password" yaml:"auth_password"`
    Salt                 null.String `boil:"salt" json:"salt,omitempty" toml:"salt" yaml:"salt,omitempty"`
    AuthUsername         null.String `boil:"auth_username" json:"auth_username,omitempty" toml:"auth_username" yaml:"auth_username,omitempty"`
    SpaceID              null.Int    `boil:"space_id" json:"space_id,omitempty" toml:"space_id" yaml:"space_id,omitempty"`
    EncryptionKeyLabel   null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`
    State                string      `boil:"state" json:"state" toml:"state" yaml:"state"`

    R   *serviceBrokerR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceBrokerL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceBroker

func FindServiceBroker(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBroker, error)

FindServiceBroker retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceBrokerAnnotation

ServiceBrokerAnnotation is an object representing the database table.

type ServiceBrokerAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceBrokerAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceBrokerAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceBrokerAnnotation

func FindServiceBrokerAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBrokerAnnotation, error)

FindServiceBrokerAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceBrokerAnnotationDeleter

type ServiceBrokerAnnotationDeleter interface {
    Delete(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceBrokerAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceBrokerAnnotationFinder

type ServiceBrokerAnnotationFinder interface {
    FindServiceBrokerAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBrokerAnnotation, error)
}

type ServiceBrokerAnnotationFinisher

type ServiceBrokerAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBrokerAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceBrokerAnnotationInserter

type ServiceBrokerAnnotationInserter interface {
    Insert(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceBrokerAnnotationReloader

type ServiceBrokerAnnotationReloader interface {
    Reload(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceBrokerAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceBrokerAnnotationSlice

ServiceBrokerAnnotationSlice is an alias for a slice of pointers to ServiceBrokerAnnotation. This should almost always be used instead of []ServiceBrokerAnnotation.

type ServiceBrokerAnnotationSlice []*ServiceBrokerAnnotation

type ServiceBrokerAnnotationUpdater

type ServiceBrokerAnnotationUpdater interface {
    Update(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceBrokerAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceBrokerAnnotationUpserter

type ServiceBrokerAnnotationUpserter interface {
    Upsert(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceBrokerDeleter

type ServiceBrokerDeleter interface {
    Delete(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceBrokerSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceBrokerFinder

type ServiceBrokerFinder interface {
    FindServiceBroker(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBroker, error)
}

type ServiceBrokerFinisher

type ServiceBrokerFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBroker, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceBrokerInserter

type ServiceBrokerInserter interface {
    Insert(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceBrokerLabel

ServiceBrokerLabel is an object representing the database table.

type ServiceBrokerLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceBrokerLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceBrokerLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceBrokerLabel

func FindServiceBrokerLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBrokerLabel, error)

FindServiceBrokerLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceBrokerLabelDeleter

type ServiceBrokerLabelDeleter interface {
    Delete(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceBrokerLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceBrokerLabelFinder

type ServiceBrokerLabelFinder interface {
    FindServiceBrokerLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBrokerLabel, error)
}

type ServiceBrokerLabelFinisher

type ServiceBrokerLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBrokerLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceBrokerLabelInserter

type ServiceBrokerLabelInserter interface {
    Insert(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceBrokerLabelReloader

type ServiceBrokerLabelReloader interface {
    Reload(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceBrokerLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceBrokerLabelSlice

ServiceBrokerLabelSlice is an alias for a slice of pointers to ServiceBrokerLabel. This should almost always be used instead of []ServiceBrokerLabel.

type ServiceBrokerLabelSlice []*ServiceBrokerLabel

type ServiceBrokerLabelUpdater

type ServiceBrokerLabelUpdater interface {
    Update(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceBrokerLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceBrokerLabelUpserter

type ServiceBrokerLabelUpserter interface {
    Upsert(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceBrokerReloader

type ServiceBrokerReloader interface {
    Reload(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceBrokerSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceBrokerSlice

ServiceBrokerSlice is an alias for a slice of pointers to ServiceBroker. This should almost always be used instead of []ServiceBroker.

type ServiceBrokerSlice []*ServiceBroker

type ServiceBrokerUpdateRequest

ServiceBrokerUpdateRequest is an object representing the database table.

type ServiceBrokerUpdateRequest struct {
    ID                   int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                 string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt            time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt            null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                 null.String `boil:"name" json:"name,omitempty" toml:"name" yaml:"name,omitempty"`
    BrokerURL            null.String `boil:"broker_url" json:"broker_url,omitempty" toml:"broker_url" yaml:"broker_url,omitempty"`
    Authentication       null.String `boil:"authentication" json:"authentication,omitempty" toml:"authentication" yaml:"authentication,omitempty"`
    Salt                 null.String `boil:"salt" json:"salt,omitempty" toml:"salt" yaml:"salt,omitempty"`
    EncryptionKeyLabel   null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`
    ServiceBrokerID      int         `boil:"service_broker_id" json:"service_broker_id" toml:"service_broker_id" yaml:"service_broker_id"`
    FKServiceBrokersID   null.Int    `boil:"fk_service_brokers_id" json:"fk_service_brokers_id,omitempty" toml:"fk_service_brokers_id" yaml:"fk_service_brokers_id,omitempty"`

    R   *serviceBrokerUpdateRequestR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceBrokerUpdateRequestL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceBrokerUpdateRequest

func FindServiceBrokerUpdateRequest(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBrokerUpdateRequest, error)

FindServiceBrokerUpdateRequest retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceBrokerUpdateRequestAnnotation

ServiceBrokerUpdateRequestAnnotation is an object representing the database table.

type ServiceBrokerUpdateRequestAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceBrokerUpdateRequestAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceBrokerUpdateRequestAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceBrokerUpdateRequestAnnotation

func FindServiceBrokerUpdateRequestAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBrokerUpdateRequestAnnotation, error)

FindServiceBrokerUpdateRequestAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceBrokerUpdateRequestAnnotationDeleter

type ServiceBrokerUpdateRequestAnnotationDeleter interface {
    Delete(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceBrokerUpdateRequestAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceBrokerUpdateRequestAnnotationFinder

type ServiceBrokerUpdateRequestAnnotationFinder interface {
    FindServiceBrokerUpdateRequestAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBrokerUpdateRequestAnnotation, error)
}

type ServiceBrokerUpdateRequestAnnotationFinisher

type ServiceBrokerUpdateRequestAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBrokerUpdateRequestAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerUpdateRequestAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceBrokerUpdateRequestAnnotationInserter

type ServiceBrokerUpdateRequestAnnotationInserter interface {
    Insert(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceBrokerUpdateRequestAnnotationReloader

type ServiceBrokerUpdateRequestAnnotationReloader interface {
    Reload(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceBrokerUpdateRequestAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceBrokerUpdateRequestAnnotationSlice

ServiceBrokerUpdateRequestAnnotationSlice is an alias for a slice of pointers to ServiceBrokerUpdateRequestAnnotation. This should almost always be used instead of []ServiceBrokerUpdateRequestAnnotation.

type ServiceBrokerUpdateRequestAnnotationSlice []*ServiceBrokerUpdateRequestAnnotation

type ServiceBrokerUpdateRequestAnnotationUpdater

type ServiceBrokerUpdateRequestAnnotationUpdater interface {
    Update(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceBrokerUpdateRequestAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceBrokerUpdateRequestAnnotationUpserter

type ServiceBrokerUpdateRequestAnnotationUpserter interface {
    Upsert(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceBrokerUpdateRequestDeleter

type ServiceBrokerUpdateRequestDeleter interface {
    Delete(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceBrokerUpdateRequestSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceBrokerUpdateRequestFinder

type ServiceBrokerUpdateRequestFinder interface {
    FindServiceBrokerUpdateRequest(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBrokerUpdateRequest, error)
}

type ServiceBrokerUpdateRequestFinisher

type ServiceBrokerUpdateRequestFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBrokerUpdateRequest, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerUpdateRequestSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceBrokerUpdateRequestInserter

type ServiceBrokerUpdateRequestInserter interface {
    Insert(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceBrokerUpdateRequestLabel

ServiceBrokerUpdateRequestLabel is an object representing the database table.

type ServiceBrokerUpdateRequestLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceBrokerUpdateRequestLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceBrokerUpdateRequestLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceBrokerUpdateRequestLabel

func FindServiceBrokerUpdateRequestLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBrokerUpdateRequestLabel, error)

FindServiceBrokerUpdateRequestLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceBrokerUpdateRequestLabelDeleter

type ServiceBrokerUpdateRequestLabelDeleter interface {
    Delete(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceBrokerUpdateRequestLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceBrokerUpdateRequestLabelFinder

type ServiceBrokerUpdateRequestLabelFinder interface {
    FindServiceBrokerUpdateRequestLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceBrokerUpdateRequestLabel, error)
}

type ServiceBrokerUpdateRequestLabelFinisher

type ServiceBrokerUpdateRequestLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBrokerUpdateRequestLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerUpdateRequestLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceBrokerUpdateRequestLabelInserter

type ServiceBrokerUpdateRequestLabelInserter interface {
    Insert(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceBrokerUpdateRequestLabelReloader

type ServiceBrokerUpdateRequestLabelReloader interface {
    Reload(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceBrokerUpdateRequestLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceBrokerUpdateRequestLabelSlice

ServiceBrokerUpdateRequestLabelSlice is an alias for a slice of pointers to ServiceBrokerUpdateRequestLabel. This should almost always be used instead of []ServiceBrokerUpdateRequestLabel.

type ServiceBrokerUpdateRequestLabelSlice []*ServiceBrokerUpdateRequestLabel

type ServiceBrokerUpdateRequestLabelUpdater

type ServiceBrokerUpdateRequestLabelUpdater interface {
    Update(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceBrokerUpdateRequestLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceBrokerUpdateRequestLabelUpserter

type ServiceBrokerUpdateRequestLabelUpserter interface {
    Upsert(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceBrokerUpdateRequestReloader

type ServiceBrokerUpdateRequestReloader interface {
    Reload(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceBrokerUpdateRequestSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceBrokerUpdateRequestSlice

ServiceBrokerUpdateRequestSlice is an alias for a slice of pointers to ServiceBrokerUpdateRequest. This should almost always be used instead of []ServiceBrokerUpdateRequest.

type ServiceBrokerUpdateRequestSlice []*ServiceBrokerUpdateRequest

type ServiceBrokerUpdateRequestUpdater

type ServiceBrokerUpdateRequestUpdater interface {
    Update(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceBrokerUpdateRequestSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceBrokerUpdateRequestUpserter

type ServiceBrokerUpdateRequestUpserter interface {
    Upsert(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceBrokerUpdater

type ServiceBrokerUpdater interface {
    Update(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceBrokerSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceBrokerUpserter

type ServiceBrokerUpserter interface {
    Upsert(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceDashboardClient

ServiceDashboardClient is an object representing the database table.

type ServiceDashboardClient struct {
    ID              int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    CreatedAt       time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt       null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    UaaID           string    `boil:"uaa_id" json:"uaa_id" toml:"uaa_id" yaml:"uaa_id"`
    ServiceBrokerID null.Int  `boil:"service_broker_id" json:"service_broker_id,omitempty" toml:"service_broker_id" yaml:"service_broker_id,omitempty"`

    R   *serviceDashboardClientR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceDashboardClientL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceDashboardClient

func FindServiceDashboardClient(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceDashboardClient, error)

FindServiceDashboardClient retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceDashboardClientDeleter

type ServiceDashboardClientDeleter interface {
    Delete(o *ServiceDashboardClient, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceDashboardClientSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceDashboardClientFinder

type ServiceDashboardClientFinder interface {
    FindServiceDashboardClient(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceDashboardClient, error)
}

type ServiceDashboardClientFinisher

type ServiceDashboardClientFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceDashboardClient, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceDashboardClientSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceDashboardClientInserter

type ServiceDashboardClientInserter interface {
    Insert(o *ServiceDashboardClient, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceDashboardClientReloader

type ServiceDashboardClientReloader interface {
    Reload(o *ServiceDashboardClient, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceDashboardClientSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceDashboardClientSlice

ServiceDashboardClientSlice is an alias for a slice of pointers to ServiceDashboardClient. This should almost always be used instead of []ServiceDashboardClient.

type ServiceDashboardClientSlice []*ServiceDashboardClient

type ServiceDashboardClientUpdater

type ServiceDashboardClientUpdater interface {
    Update(o *ServiceDashboardClient, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceDashboardClientSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceDashboardClientUpserter

type ServiceDashboardClientUpserter interface {
    Upsert(o *ServiceDashboardClient, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceDeleter

type ServiceDeleter interface {
    Delete(o *Service, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceFinder

type ServiceFinder interface {
    FindService(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Service, error)
}

type ServiceFinisher

type ServiceFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Service, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceInserter

type ServiceInserter interface {
    Insert(o *Service, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceInstance

ServiceInstance is an object representing the database table.

type ServiceInstance struct {
    ID                   int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                 string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt            time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt            null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                 string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    Credentials          null.String `boil:"credentials" json:"credentials,omitempty" toml:"credentials" yaml:"credentials,omitempty"`
    GatewayName          null.String `boil:"gateway_name" json:"gateway_name,omitempty" toml:"gateway_name" yaml:"gateway_name,omitempty"`
    GatewayData          null.String `boil:"gateway_data" json:"gateway_data,omitempty" toml:"gateway_data" yaml:"gateway_data,omitempty"`
    SpaceID              int         `boil:"space_id" json:"space_id" toml:"space_id" yaml:"space_id"`
    ServicePlanID        null.Int    `boil:"service_plan_id" json:"service_plan_id,omitempty" toml:"service_plan_id" yaml:"service_plan_id,omitempty"`
    Salt                 null.String `boil:"salt" json:"salt,omitempty" toml:"salt" yaml:"salt,omitempty"`
    DashboardURL         null.String `boil:"dashboard_url" json:"dashboard_url,omitempty" toml:"dashboard_url" yaml:"dashboard_url,omitempty"`
    IsGatewayService     bool        `boil:"is_gateway_service" json:"is_gateway_service" toml:"is_gateway_service" yaml:"is_gateway_service"`
    SyslogDrainURL       null.String `boil:"syslog_drain_url" json:"syslog_drain_url,omitempty" toml:"syslog_drain_url" yaml:"syslog_drain_url,omitempty"`
    Tags                 null.String `boil:"tags" json:"tags,omitempty" toml:"tags" yaml:"tags,omitempty"`
    RouteServiceURL      null.String `boil:"route_service_url" json:"route_service_url,omitempty" toml:"route_service_url" yaml:"route_service_url,omitempty"`
    EncryptionKeyLabel   null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`
    MaintenanceInfo      null.String `boil:"maintenance_info" json:"maintenance_info,omitempty" toml:"maintenance_info" yaml:"maintenance_info,omitempty"`

    R   *serviceInstanceR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceInstanceL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceInstance

func FindServiceInstance(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceInstance, error)

FindServiceInstance retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceInstanceAnnotation

ServiceInstanceAnnotation is an object representing the database table.

type ServiceInstanceAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceInstanceAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceInstanceAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceInstanceAnnotation

func FindServiceInstanceAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceInstanceAnnotation, error)

FindServiceInstanceAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceInstanceAnnotationDeleter

type ServiceInstanceAnnotationDeleter interface {
    Delete(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceInstanceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceInstanceAnnotationFinder

type ServiceInstanceAnnotationFinder interface {
    FindServiceInstanceAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceInstanceAnnotation, error)
}

type ServiceInstanceAnnotationFinisher

type ServiceInstanceAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceInstanceAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceInstanceAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceInstanceAnnotationInserter

type ServiceInstanceAnnotationInserter interface {
    Insert(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceInstanceAnnotationReloader

type ServiceInstanceAnnotationReloader interface {
    Reload(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceInstanceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceInstanceAnnotationSlice

ServiceInstanceAnnotationSlice is an alias for a slice of pointers to ServiceInstanceAnnotation. This should almost always be used instead of []ServiceInstanceAnnotation.

type ServiceInstanceAnnotationSlice []*ServiceInstanceAnnotation

type ServiceInstanceAnnotationUpdater

type ServiceInstanceAnnotationUpdater interface {
    Update(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceInstanceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceInstanceAnnotationUpserter

type ServiceInstanceAnnotationUpserter interface {
    Upsert(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceInstanceDeleter

type ServiceInstanceDeleter interface {
    Delete(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceInstanceSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceInstanceFinder

type ServiceInstanceFinder interface {
    FindServiceInstance(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceInstance, error)
}

type ServiceInstanceFinisher

type ServiceInstanceFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceInstance, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceInstanceSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceInstanceInserter

type ServiceInstanceInserter interface {
    Insert(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceInstanceLabel

ServiceInstanceLabel is an object representing the database table.

type ServiceInstanceLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceInstanceLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceInstanceLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceInstanceLabel

func FindServiceInstanceLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceInstanceLabel, error)

FindServiceInstanceLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceInstanceLabelDeleter

type ServiceInstanceLabelDeleter interface {
    Delete(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceInstanceLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceInstanceLabelFinder

type ServiceInstanceLabelFinder interface {
    FindServiceInstanceLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceInstanceLabel, error)
}

type ServiceInstanceLabelFinisher

type ServiceInstanceLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceInstanceLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceInstanceLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceInstanceLabelInserter

type ServiceInstanceLabelInserter interface {
    Insert(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceInstanceLabelReloader

type ServiceInstanceLabelReloader interface {
    Reload(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceInstanceLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceInstanceLabelSlice

ServiceInstanceLabelSlice is an alias for a slice of pointers to ServiceInstanceLabel. This should almost always be used instead of []ServiceInstanceLabel.

type ServiceInstanceLabelSlice []*ServiceInstanceLabel

type ServiceInstanceLabelUpdater

type ServiceInstanceLabelUpdater interface {
    Update(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceInstanceLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceInstanceLabelUpserter

type ServiceInstanceLabelUpserter interface {
    Upsert(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceInstanceOperation

ServiceInstanceOperation is an object representing the database table.

type ServiceInstanceOperation struct {
    ID                      int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                    string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt               time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt               null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ServiceInstanceID       null.Int    `boil:"service_instance_id" json:"service_instance_id,omitempty" toml:"service_instance_id" yaml:"service_instance_id,omitempty"`
    Type                    null.String `boil:"type" json:"type,omitempty" toml:"type" yaml:"type,omitempty"`
    State                   null.String `boil:"state" json:"state,omitempty" toml:"state" yaml:"state,omitempty"`
    Description             null.String `boil:"description" json:"description,omitempty" toml:"description" yaml:"description,omitempty"`
    ProposedChanges         string      `boil:"proposed_changes" json:"proposed_changes" toml:"proposed_changes" yaml:"proposed_changes"`
    BrokerProvidedOperation null.String `boil:"broker_provided_operation" json:"broker_provided_operation,omitempty" toml:"broker_provided_operation" yaml:"broker_provided_operation,omitempty"`

    R   *serviceInstanceOperationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceInstanceOperationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceInstanceOperation

func FindServiceInstanceOperation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceInstanceOperation, error)

FindServiceInstanceOperation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceInstanceOperationDeleter

type ServiceInstanceOperationDeleter interface {
    Delete(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceInstanceOperationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceInstanceOperationFinder

type ServiceInstanceOperationFinder interface {
    FindServiceInstanceOperation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceInstanceOperation, error)
}

type ServiceInstanceOperationFinisher

type ServiceInstanceOperationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceInstanceOperation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceInstanceOperationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceInstanceOperationInserter

type ServiceInstanceOperationInserter interface {
    Insert(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceInstanceOperationReloader

type ServiceInstanceOperationReloader interface {
    Reload(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceInstanceOperationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceInstanceOperationSlice

ServiceInstanceOperationSlice is an alias for a slice of pointers to ServiceInstanceOperation. This should almost always be used instead of []ServiceInstanceOperation.

type ServiceInstanceOperationSlice []*ServiceInstanceOperation

type ServiceInstanceOperationUpdater

type ServiceInstanceOperationUpdater interface {
    Update(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceInstanceOperationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceInstanceOperationUpserter

type ServiceInstanceOperationUpserter interface {
    Upsert(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceInstanceReloader

type ServiceInstanceReloader interface {
    Reload(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceInstanceSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceInstanceSlice

ServiceInstanceSlice is an alias for a slice of pointers to ServiceInstance. This should almost always be used instead of []ServiceInstance.

type ServiceInstanceSlice []*ServiceInstance

type ServiceInstanceUpdater

type ServiceInstanceUpdater interface {
    Update(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceInstanceSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceInstanceUpserter

type ServiceInstanceUpserter interface {
    Upsert(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceKey

ServiceKey is an object representing the database table.

type ServiceKey struct {
    ID                   int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                 string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt            time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt            null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                 string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    Salt                 null.String `boil:"salt" json:"salt,omitempty" toml:"salt" yaml:"salt,omitempty"`
    Credentials          string      `boil:"credentials" json:"credentials" toml:"credentials" yaml:"credentials"`
    ServiceInstanceID    int         `boil:"service_instance_id" json:"service_instance_id" toml:"service_instance_id" yaml:"service_instance_id"`
    EncryptionKeyLabel   null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`

    R   *serviceKeyR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceKeyL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceKey

func FindServiceKey(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceKey, error)

FindServiceKey retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceKeyAnnotation

ServiceKeyAnnotation is an object representing the database table.

type ServiceKeyAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceKeyAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceKeyAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceKeyAnnotation

func FindServiceKeyAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceKeyAnnotation, error)

FindServiceKeyAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceKeyAnnotationDeleter

type ServiceKeyAnnotationDeleter interface {
    Delete(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceKeyAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceKeyAnnotationFinder

type ServiceKeyAnnotationFinder interface {
    FindServiceKeyAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceKeyAnnotation, error)
}

type ServiceKeyAnnotationFinisher

type ServiceKeyAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceKeyAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceKeyAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceKeyAnnotationInserter

type ServiceKeyAnnotationInserter interface {
    Insert(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceKeyAnnotationReloader

type ServiceKeyAnnotationReloader interface {
    Reload(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceKeyAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceKeyAnnotationSlice

ServiceKeyAnnotationSlice is an alias for a slice of pointers to ServiceKeyAnnotation. This should almost always be used instead of []ServiceKeyAnnotation.

type ServiceKeyAnnotationSlice []*ServiceKeyAnnotation

type ServiceKeyAnnotationUpdater

type ServiceKeyAnnotationUpdater interface {
    Update(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceKeyAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceKeyAnnotationUpserter

type ServiceKeyAnnotationUpserter interface {
    Upsert(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceKeyDeleter

type ServiceKeyDeleter interface {
    Delete(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceKeySlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceKeyFinder

type ServiceKeyFinder interface {
    FindServiceKey(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceKey, error)
}

type ServiceKeyFinisher

type ServiceKeyFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceKey, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceKeySlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceKeyInserter

type ServiceKeyInserter interface {
    Insert(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceKeyLabel

ServiceKeyLabel is an object representing the database table.

type ServiceKeyLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceKeyLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceKeyLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceKeyLabel

func FindServiceKeyLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceKeyLabel, error)

FindServiceKeyLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceKeyLabelDeleter

type ServiceKeyLabelDeleter interface {
    Delete(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceKeyLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceKeyLabelFinder

type ServiceKeyLabelFinder interface {
    FindServiceKeyLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceKeyLabel, error)
}

type ServiceKeyLabelFinisher

type ServiceKeyLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceKeyLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceKeyLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceKeyLabelInserter

type ServiceKeyLabelInserter interface {
    Insert(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceKeyLabelReloader

type ServiceKeyLabelReloader interface {
    Reload(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceKeyLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceKeyLabelSlice

ServiceKeyLabelSlice is an alias for a slice of pointers to ServiceKeyLabel. This should almost always be used instead of []ServiceKeyLabel.

type ServiceKeyLabelSlice []*ServiceKeyLabel

type ServiceKeyLabelUpdater

type ServiceKeyLabelUpdater interface {
    Update(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceKeyLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceKeyLabelUpserter

type ServiceKeyLabelUpserter interface {
    Upsert(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceKeyOperation

ServiceKeyOperation is an object representing the database table.

type ServiceKeyOperation struct {
    ID                      int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    CreatedAt               time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt               null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ServiceKeyID            null.Int    `boil:"service_key_id" json:"service_key_id,omitempty" toml:"service_key_id" yaml:"service_key_id,omitempty"`
    State                   string      `boil:"state" json:"state" toml:"state" yaml:"state"`
    Type                    string      `boil:"type" json:"type" toml:"type" yaml:"type"`
    Description             null.String `boil:"description" json:"description,omitempty" toml:"description" yaml:"description,omitempty"`
    BrokerProvidedOperation null.String `boil:"broker_provided_operation" json:"broker_provided_operation,omitempty" toml:"broker_provided_operation" yaml:"broker_provided_operation,omitempty"`

    R   *serviceKeyOperationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceKeyOperationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceKeyOperation

func FindServiceKeyOperation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceKeyOperation, error)

FindServiceKeyOperation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceKeyOperationDeleter

type ServiceKeyOperationDeleter interface {
    Delete(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceKeyOperationFinder

type ServiceKeyOperationFinder interface {
    FindServiceKeyOperation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceKeyOperation, error)
}

type ServiceKeyOperationFinisher

type ServiceKeyOperationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceKeyOperation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceKeyOperationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceKeyOperationInserter

type ServiceKeyOperationInserter interface {
    Insert(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceKeyOperationReloader

type ServiceKeyOperationReloader interface {
    Reload(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceKeyOperationSlice

ServiceKeyOperationSlice is an alias for a slice of pointers to ServiceKeyOperation. This should almost always be used instead of []ServiceKeyOperation.

type ServiceKeyOperationSlice []*ServiceKeyOperation

type ServiceKeyOperationUpdater

type ServiceKeyOperationUpdater interface {
    Update(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceKeyOperationUpserter

type ServiceKeyOperationUpserter interface {
    Upsert(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceKeyReloader

type ServiceKeyReloader interface {
    Reload(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceKeySlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceKeySlice

ServiceKeySlice is an alias for a slice of pointers to ServiceKey. This should almost always be used instead of []ServiceKey.

type ServiceKeySlice []*ServiceKey

type ServiceKeyUpdater

type ServiceKeyUpdater interface {
    Update(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceKeySlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceKeyUpserter

type ServiceKeyUpserter interface {
    Upsert(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceOfferingAnnotation

ServiceOfferingAnnotation is an object representing the database table.

type ServiceOfferingAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceOfferingAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceOfferingAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceOfferingAnnotation

func FindServiceOfferingAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceOfferingAnnotation, error)

FindServiceOfferingAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceOfferingAnnotationDeleter

type ServiceOfferingAnnotationDeleter interface {
    Delete(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceOfferingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceOfferingAnnotationFinder

type ServiceOfferingAnnotationFinder interface {
    FindServiceOfferingAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceOfferingAnnotation, error)
}

type ServiceOfferingAnnotationFinisher

type ServiceOfferingAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceOfferingAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceOfferingAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceOfferingAnnotationInserter

type ServiceOfferingAnnotationInserter interface {
    Insert(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceOfferingAnnotationReloader

type ServiceOfferingAnnotationReloader interface {
    Reload(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceOfferingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceOfferingAnnotationSlice

ServiceOfferingAnnotationSlice is an alias for a slice of pointers to ServiceOfferingAnnotation. This should almost always be used instead of []ServiceOfferingAnnotation.

type ServiceOfferingAnnotationSlice []*ServiceOfferingAnnotation

type ServiceOfferingAnnotationUpdater

type ServiceOfferingAnnotationUpdater interface {
    Update(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceOfferingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceOfferingAnnotationUpserter

type ServiceOfferingAnnotationUpserter interface {
    Upsert(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceOfferingLabel

ServiceOfferingLabel is an object representing the database table.

type ServiceOfferingLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *serviceOfferingLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceOfferingLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceOfferingLabel

func FindServiceOfferingLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceOfferingLabel, error)

FindServiceOfferingLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceOfferingLabelDeleter

type ServiceOfferingLabelDeleter interface {
    Delete(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceOfferingLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceOfferingLabelFinder

type ServiceOfferingLabelFinder interface {
    FindServiceOfferingLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceOfferingLabel, error)
}

type ServiceOfferingLabelFinisher

type ServiceOfferingLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceOfferingLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceOfferingLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceOfferingLabelInserter

type ServiceOfferingLabelInserter interface {
    Insert(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceOfferingLabelReloader

type ServiceOfferingLabelReloader interface {
    Reload(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceOfferingLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceOfferingLabelSlice

ServiceOfferingLabelSlice is an alias for a slice of pointers to ServiceOfferingLabel. This should almost always be used instead of []ServiceOfferingLabel.

type ServiceOfferingLabelSlice []*ServiceOfferingLabel

type ServiceOfferingLabelUpdater

type ServiceOfferingLabelUpdater interface {
    Update(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceOfferingLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceOfferingLabelUpserter

type ServiceOfferingLabelUpserter interface {
    Upsert(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServicePlan

ServicePlan is an object representing the database table.

type ServicePlan struct {
    ID                     int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                   string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt              time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt              null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                   string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    Description            string      `boil:"description" json:"description" toml:"description" yaml:"description"`
    Free                   bool        `boil:"free" json:"free" toml:"free" yaml:"free"`
    ServiceID              int         `boil:"service_id" json:"service_id" toml:"service_id" yaml:"service_id"`
    Extra                  null.String `boil:"extra" json:"extra,omitempty" toml:"extra" yaml:"extra,omitempty"`
    UniqueID               string      `boil:"unique_id" json:"unique_id" toml:"unique_id" yaml:"unique_id"`
    Public                 null.Bool   `boil:"public" json:"public,omitempty" toml:"public" yaml:"public,omitempty"`
    Active                 null.Bool   `boil:"active" json:"active,omitempty" toml:"active" yaml:"active,omitempty"`
    Bindable               null.Bool   `boil:"bindable" json:"bindable,omitempty" toml:"bindable" yaml:"bindable,omitempty"`
    CreateInstanceSchema   null.String `boil:"create_instance_schema" json:"create_instance_schema,omitempty" toml:"create_instance_schema" yaml:"create_instance_schema,omitempty"`
    UpdateInstanceSchema   null.String `boil:"update_instance_schema" json:"update_instance_schema,omitempty" toml:"update_instance_schema" yaml:"update_instance_schema,omitempty"`
    CreateBindingSchema    null.String `boil:"create_binding_schema" json:"create_binding_schema,omitempty" toml:"create_binding_schema" yaml:"create_binding_schema,omitempty"`
    PlanUpdateable         null.Bool   `boil:"plan_updateable" json:"plan_updateable,omitempty" toml:"plan_updateable" yaml:"plan_updateable,omitempty"`
    MaximumPollingDuration null.Int    `boil:"maximum_polling_duration" json:"maximum_polling_duration,omitempty" toml:"maximum_polling_duration" yaml:"maximum_polling_duration,omitempty"`
    MaintenanceInfo        null.String `boil:"maintenance_info" json:"maintenance_info,omitempty" toml:"maintenance_info" yaml:"maintenance_info,omitempty"`

    R   *servicePlanR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   servicePlanL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServicePlan

func FindServicePlan(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServicePlan, error)

FindServicePlan retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServicePlanAnnotation

ServicePlanAnnotation is an object representing the database table.

type ServicePlanAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *servicePlanAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   servicePlanAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServicePlanAnnotation

func FindServicePlanAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServicePlanAnnotation, error)

FindServicePlanAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServicePlanAnnotationDeleter

type ServicePlanAnnotationDeleter interface {
    Delete(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServicePlanAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServicePlanAnnotationFinder

type ServicePlanAnnotationFinder interface {
    FindServicePlanAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServicePlanAnnotation, error)
}

type ServicePlanAnnotationFinisher

type ServicePlanAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServicePlanAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServicePlanAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServicePlanAnnotationInserter

type ServicePlanAnnotationInserter interface {
    Insert(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServicePlanAnnotationReloader

type ServicePlanAnnotationReloader interface {
    Reload(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServicePlanAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServicePlanAnnotationSlice

ServicePlanAnnotationSlice is an alias for a slice of pointers to ServicePlanAnnotation. This should almost always be used instead of []ServicePlanAnnotation.

type ServicePlanAnnotationSlice []*ServicePlanAnnotation

type ServicePlanAnnotationUpdater

type ServicePlanAnnotationUpdater interface {
    Update(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServicePlanAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServicePlanAnnotationUpserter

type ServicePlanAnnotationUpserter interface {
    Upsert(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServicePlanDeleter

type ServicePlanDeleter interface {
    Delete(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServicePlanSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServicePlanFinder

type ServicePlanFinder interface {
    FindServicePlan(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServicePlan, error)
}

type ServicePlanFinisher

type ServicePlanFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServicePlan, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServicePlanSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServicePlanInserter

type ServicePlanInserter interface {
    Insert(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServicePlanLabel

ServicePlanLabel is an object representing the database table.

type ServicePlanLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *servicePlanLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   servicePlanLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServicePlanLabel

func FindServicePlanLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServicePlanLabel, error)

FindServicePlanLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServicePlanLabelDeleter

type ServicePlanLabelDeleter interface {
    Delete(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServicePlanLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServicePlanLabelFinder

type ServicePlanLabelFinder interface {
    FindServicePlanLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServicePlanLabel, error)
}

type ServicePlanLabelFinisher

type ServicePlanLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServicePlanLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServicePlanLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServicePlanLabelInserter

type ServicePlanLabelInserter interface {
    Insert(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServicePlanLabelReloader

type ServicePlanLabelReloader interface {
    Reload(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServicePlanLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServicePlanLabelSlice

ServicePlanLabelSlice is an alias for a slice of pointers to ServicePlanLabel. This should almost always be used instead of []ServicePlanLabel.

type ServicePlanLabelSlice []*ServicePlanLabel

type ServicePlanLabelUpdater

type ServicePlanLabelUpdater interface {
    Update(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServicePlanLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServicePlanLabelUpserter

type ServicePlanLabelUpserter interface {
    Upsert(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServicePlanReloader

type ServicePlanReloader interface {
    Reload(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServicePlanSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServicePlanSlice

ServicePlanSlice is an alias for a slice of pointers to ServicePlan. This should almost always be used instead of []ServicePlan.

type ServicePlanSlice []*ServicePlan

type ServicePlanUpdater

type ServicePlanUpdater interface {
    Update(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServicePlanSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServicePlanUpserter

type ServicePlanUpserter interface {
    Upsert(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServicePlanVisibility

ServicePlanVisibility is an object representing the database table.

type ServicePlanVisibility struct {
    ID             int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID           string    `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt      time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt      null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ServicePlanID  int       `boil:"service_plan_id" json:"service_plan_id" toml:"service_plan_id" yaml:"service_plan_id"`
    OrganizationID int       `boil:"organization_id" json:"organization_id" toml:"organization_id" yaml:"organization_id"`

    R   *servicePlanVisibilityR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   servicePlanVisibilityL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServicePlanVisibility

func FindServicePlanVisibility(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServicePlanVisibility, error)

FindServicePlanVisibility retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServicePlanVisibilityDeleter

type ServicePlanVisibilityDeleter interface {
    Delete(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServicePlanVisibilitySlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServicePlanVisibilityFinder

type ServicePlanVisibilityFinder interface {
    FindServicePlanVisibility(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServicePlanVisibility, error)
}

type ServicePlanVisibilityFinisher

type ServicePlanVisibilityFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServicePlanVisibility, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServicePlanVisibilitySlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServicePlanVisibilityInserter

type ServicePlanVisibilityInserter interface {
    Insert(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServicePlanVisibilityReloader

type ServicePlanVisibilityReloader interface {
    Reload(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServicePlanVisibilitySlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServicePlanVisibilitySlice

ServicePlanVisibilitySlice is an alias for a slice of pointers to ServicePlanVisibility. This should almost always be used instead of []ServicePlanVisibility.

type ServicePlanVisibilitySlice []*ServicePlanVisibility

type ServicePlanVisibilityUpdater

type ServicePlanVisibilityUpdater interface {
    Update(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServicePlanVisibilitySlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServicePlanVisibilityUpserter

type ServicePlanVisibilityUpserter interface {
    Upsert(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceReloader

type ServiceReloader interface {
    Reload(o *Service, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceSlice

ServiceSlice is an alias for a slice of pointers to Service. This should almost always be used instead of []Service.

type ServiceSlice []*Service

type ServiceUpdater

type ServiceUpdater interface {
    Update(o *Service, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceUpserter

type ServiceUpserter interface {
    Upsert(o *Service, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type ServiceUsageEvent

ServiceUsageEvent is an object representing the database table.

type ServiceUsageEvent struct {
    ID                  int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt           time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    State               string      `boil:"state" json:"state" toml:"state" yaml:"state"`
    OrgGUID             string      `boil:"org_guid" json:"org_guid" toml:"org_guid" yaml:"org_guid"`
    SpaceGUID           string      `boil:"space_guid" json:"space_guid" toml:"space_guid" yaml:"space_guid"`
    SpaceName           string      `boil:"space_name" json:"space_name" toml:"space_name" yaml:"space_name"`
    ServiceInstanceGUID string      `boil:"service_instance_guid" json:"service_instance_guid" toml:"service_instance_guid" yaml:"service_instance_guid"`
    ServiceInstanceName string      `boil:"service_instance_name" json:"service_instance_name" toml:"service_instance_name" yaml:"service_instance_name"`
    ServiceInstanceType string      `boil:"service_instance_type" json:"service_instance_type" toml:"service_instance_type" yaml:"service_instance_type"`
    ServicePlanGUID     null.String `boil:"service_plan_guid" json:"service_plan_guid,omitempty" toml:"service_plan_guid" yaml:"service_plan_guid,omitempty"`
    ServicePlanName     null.String `boil:"service_plan_name" json:"service_plan_name,omitempty" toml:"service_plan_name" yaml:"service_plan_name,omitempty"`
    ServiceGUID         null.String `boil:"service_guid" json:"service_guid,omitempty" toml:"service_guid" yaml:"service_guid,omitempty"`
    ServiceLabel        null.String `boil:"service_label" json:"service_label,omitempty" toml:"service_label" yaml:"service_label,omitempty"`
    ServiceBrokerName   null.String `boil:"service_broker_name" json:"service_broker_name,omitempty" toml:"service_broker_name" yaml:"service_broker_name,omitempty"`
    ServiceBrokerGUID   null.String `boil:"service_broker_guid" json:"service_broker_guid,omitempty" toml:"service_broker_guid" yaml:"service_broker_guid,omitempty"`

    R   *serviceUsageEventR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   serviceUsageEventL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindServiceUsageEvent

func FindServiceUsageEvent(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceUsageEvent, error)

FindServiceUsageEvent retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type ServiceUsageEventDeleter

type ServiceUsageEventDeleter interface {
    Delete(o *ServiceUsageEvent, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o ServiceUsageEventSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type ServiceUsageEventFinder

type ServiceUsageEventFinder interface {
    FindServiceUsageEvent(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*ServiceUsageEvent, error)
}

type ServiceUsageEventFinisher

type ServiceUsageEventFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*ServiceUsageEvent, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (ServiceUsageEventSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type ServiceUsageEventInserter

type ServiceUsageEventInserter interface {
    Insert(o *ServiceUsageEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type ServiceUsageEventReloader

type ServiceUsageEventReloader interface {
    Reload(o *ServiceUsageEvent, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *ServiceUsageEventSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type ServiceUsageEventSlice

ServiceUsageEventSlice is an alias for a slice of pointers to ServiceUsageEvent. This should almost always be used instead of []ServiceUsageEvent.

type ServiceUsageEventSlice []*ServiceUsageEvent

type ServiceUsageEventUpdater

type ServiceUsageEventUpdater interface {
    Update(o *ServiceUsageEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o ServiceUsageEventSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type ServiceUsageEventUpserter

type ServiceUsageEventUpserter interface {
    Upsert(o *ServiceUsageEvent, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Sidecar

Sidecar is an object representing the database table.

type Sidecar struct {
    ID        int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID      string    `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name      string    `boil:"name" json:"name" toml:"name" yaml:"name"`
    Command   string    `boil:"command" json:"command" toml:"command" yaml:"command"`
    AppGUID   string    `boil:"app_guid" json:"app_guid" toml:"app_guid" yaml:"app_guid"`
    Memory    null.Int  `boil:"memory" json:"memory,omitempty" toml:"memory" yaml:"memory,omitempty"`
    Origin    string    `boil:"origin" json:"origin" toml:"origin" yaml:"origin"`

    R   *sidecarR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   sidecarL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSidecar

func FindSidecar(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Sidecar, error)

FindSidecar retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SidecarDeleter

type SidecarDeleter interface {
    Delete(o *Sidecar, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SidecarSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SidecarFinder

type SidecarFinder interface {
    FindSidecar(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Sidecar, error)
}

type SidecarFinisher

type SidecarFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Sidecar, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SidecarSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SidecarInserter

type SidecarInserter interface {
    Insert(o *Sidecar, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SidecarProcessType

SidecarProcessType is an object representing the database table.

type SidecarProcessType struct {
    ID          int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID        string    `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt   time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt   null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Type        string    `boil:"type" json:"type" toml:"type" yaml:"type"`
    SidecarGUID string    `boil:"sidecar_guid" json:"sidecar_guid" toml:"sidecar_guid" yaml:"sidecar_guid"`
    AppGUID     string    `boil:"app_guid" json:"app_guid" toml:"app_guid" yaml:"app_guid"`

    R   *sidecarProcessTypeR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   sidecarProcessTypeL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSidecarProcessType

func FindSidecarProcessType(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*SidecarProcessType, error)

FindSidecarProcessType retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SidecarProcessTypeDeleter

type SidecarProcessTypeDeleter interface {
    Delete(o *SidecarProcessType, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SidecarProcessTypeFinder

type SidecarProcessTypeFinder interface {
    FindSidecarProcessType(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*SidecarProcessType, error)
}

type SidecarProcessTypeFinisher

type SidecarProcessTypeFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*SidecarProcessType, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SidecarProcessTypeSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SidecarProcessTypeInserter

type SidecarProcessTypeInserter interface {
    Insert(o *SidecarProcessType, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SidecarProcessTypeReloader

type SidecarProcessTypeReloader interface {
    Reload(o *SidecarProcessType, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SidecarProcessTypeSlice

SidecarProcessTypeSlice is an alias for a slice of pointers to SidecarProcessType. This should almost always be used instead of []SidecarProcessType.

type SidecarProcessTypeSlice []*SidecarProcessType

type SidecarProcessTypeUpdater

type SidecarProcessTypeUpdater interface {
    Update(o *SidecarProcessType, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SidecarProcessTypeUpserter

type SidecarProcessTypeUpserter interface {
    Upsert(o *SidecarProcessType, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type SidecarReloader

type SidecarReloader interface {
    Reload(o *Sidecar, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SidecarSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SidecarSlice

SidecarSlice is an alias for a slice of pointers to Sidecar. This should almost always be used instead of []Sidecar.

type SidecarSlice []*Sidecar

type SidecarUpdater

type SidecarUpdater interface {
    Update(o *Sidecar, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SidecarSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SidecarUpserter

type SidecarUpserter interface {
    Upsert(o *Sidecar, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Space

Space is an object representing the database table.

type Space struct {
    ID                     int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                   string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt              time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt              null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                   string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    OrganizationID         int         `boil:"organization_id" json:"organization_id" toml:"organization_id" yaml:"organization_id"`
    SpaceQuotaDefinitionID null.Int    `boil:"space_quota_definition_id" json:"space_quota_definition_id,omitempty" toml:"space_quota_definition_id" yaml:"space_quota_definition_id,omitempty"`
    AllowSSH               null.Bool   `boil:"allow_ssh" json:"allow_ssh,omitempty" toml:"allow_ssh" yaml:"allow_ssh,omitempty"`
    IsolationSegmentGUID   null.String `boil:"isolation_segment_guid" json:"isolation_segment_guid,omitempty" toml:"isolation_segment_guid" yaml:"isolation_segment_guid,omitempty"`

    R   *spaceR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   spaceL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSpace

func FindSpace(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Space, error)

FindSpace retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SpaceAnnotation

SpaceAnnotation is an object representing the database table.

type SpaceAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *spaceAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   spaceAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSpaceAnnotation

func FindSpaceAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*SpaceAnnotation, error)

FindSpaceAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SpaceAnnotationDeleter

type SpaceAnnotationDeleter interface {
    Delete(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SpaceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SpaceAnnotationFinder

type SpaceAnnotationFinder interface {
    FindSpaceAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*SpaceAnnotation, error)
}

type SpaceAnnotationFinisher

type SpaceAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*SpaceAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SpaceAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SpaceAnnotationInserter

type SpaceAnnotationInserter interface {
    Insert(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SpaceAnnotationReloader

type SpaceAnnotationReloader interface {
    Reload(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SpaceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SpaceAnnotationSlice

SpaceAnnotationSlice is an alias for a slice of pointers to SpaceAnnotation. This should almost always be used instead of []SpaceAnnotation.

type SpaceAnnotationSlice []*SpaceAnnotation

type SpaceAnnotationUpdater

type SpaceAnnotationUpdater interface {
    Update(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SpaceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SpaceAnnotationUpserter

type SpaceAnnotationUpserter interface {
    Upsert(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type SpaceDeleter

type SpaceDeleter interface {
    Delete(o *Space, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SpaceSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SpaceFinder

type SpaceFinder interface {
    FindSpace(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Space, error)
}

type SpaceFinisher

type SpaceFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Space, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SpaceSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SpaceInserter

type SpaceInserter interface {
    Insert(o *Space, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SpaceLabel

SpaceLabel is an object representing the database table.

type SpaceLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *spaceLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   spaceLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSpaceLabel

func FindSpaceLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*SpaceLabel, error)

FindSpaceLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SpaceLabelDeleter

type SpaceLabelDeleter interface {
    Delete(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SpaceLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SpaceLabelFinder

type SpaceLabelFinder interface {
    FindSpaceLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*SpaceLabel, error)
}

type SpaceLabelFinisher

type SpaceLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*SpaceLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SpaceLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SpaceLabelInserter

type SpaceLabelInserter interface {
    Insert(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SpaceLabelReloader

type SpaceLabelReloader interface {
    Reload(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SpaceLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SpaceLabelSlice

SpaceLabelSlice is an alias for a slice of pointers to SpaceLabel. This should almost always be used instead of []SpaceLabel.

type SpaceLabelSlice []*SpaceLabel

type SpaceLabelUpdater

type SpaceLabelUpdater interface {
    Update(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SpaceLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SpaceLabelUpserter

type SpaceLabelUpserter interface {
    Upsert(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type SpaceQuotaDefinition

SpaceQuotaDefinition is an object representing the database table.

type SpaceQuotaDefinition struct {
    ID                      int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                    string    `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt               time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt               null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                    string    `boil:"name" json:"name" toml:"name" yaml:"name"`
    NonBasicServicesAllowed bool      `boil:"non_basic_services_allowed" json:"non_basic_services_allowed" toml:"non_basic_services_allowed" yaml:"non_basic_services_allowed"`
    TotalServices           int       `boil:"total_services" json:"total_services" toml:"total_services" yaml:"total_services"`
    MemoryLimit             int       `boil:"memory_limit" json:"memory_limit" toml:"memory_limit" yaml:"memory_limit"`
    TotalRoutes             int       `boil:"total_routes" json:"total_routes" toml:"total_routes" yaml:"total_routes"`
    InstanceMemoryLimit     int       `boil:"instance_memory_limit" json:"instance_memory_limit" toml:"instance_memory_limit" yaml:"instance_memory_limit"`
    OrganizationID          int       `boil:"organization_id" json:"organization_id" toml:"organization_id" yaml:"organization_id"`
    AppInstanceLimit        null.Int  `boil:"app_instance_limit" json:"app_instance_limit,omitempty" toml:"app_instance_limit" yaml:"app_instance_limit,omitempty"`
    AppTaskLimit            null.Int  `boil:"app_task_limit" json:"app_task_limit,omitempty" toml:"app_task_limit" yaml:"app_task_limit,omitempty"`
    TotalServiceKeys        int       `boil:"total_service_keys" json:"total_service_keys" toml:"total_service_keys" yaml:"total_service_keys"`
    TotalReservedRoutePorts null.Int  `boil:"total_reserved_route_ports" json:"total_reserved_route_ports,omitempty" toml:"total_reserved_route_ports" yaml:"total_reserved_route_ports,omitempty"`

    R   *spaceQuotaDefinitionR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   spaceQuotaDefinitionL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSpaceQuotaDefinition

func FindSpaceQuotaDefinition(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*SpaceQuotaDefinition, error)

FindSpaceQuotaDefinition retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SpaceQuotaDefinitionDeleter

type SpaceQuotaDefinitionDeleter interface {
    Delete(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SpaceQuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SpaceQuotaDefinitionFinder

type SpaceQuotaDefinitionFinder interface {
    FindSpaceQuotaDefinition(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*SpaceQuotaDefinition, error)
}

type SpaceQuotaDefinitionFinisher

type SpaceQuotaDefinitionFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*SpaceQuotaDefinition, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SpaceQuotaDefinitionSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SpaceQuotaDefinitionInserter

type SpaceQuotaDefinitionInserter interface {
    Insert(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SpaceQuotaDefinitionReloader

type SpaceQuotaDefinitionReloader interface {
    Reload(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SpaceQuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SpaceQuotaDefinitionSlice

SpaceQuotaDefinitionSlice is an alias for a slice of pointers to SpaceQuotaDefinition. This should almost always be used instead of []SpaceQuotaDefinition.

type SpaceQuotaDefinitionSlice []*SpaceQuotaDefinition

type SpaceQuotaDefinitionUpdater

type SpaceQuotaDefinitionUpdater interface {
    Update(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SpaceQuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SpaceQuotaDefinitionUpserter

type SpaceQuotaDefinitionUpserter interface {
    Upsert(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type SpaceReloader

type SpaceReloader interface {
    Reload(o *Space, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SpaceSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SpaceSlice

SpaceSlice is an alias for a slice of pointers to Space. This should almost always be used instead of []Space.

type SpaceSlice []*Space

type SpaceUpdater

type SpaceUpdater interface {
    Update(o *Space, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SpaceSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SpaceUpserter

type SpaceUpserter interface {
    Upsert(o *Space, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type SpacesApplicationSupporter

SpacesApplicationSupporter is an object representing the database table.

type SpacesApplicationSupporter struct {
    SpacesApplicationSupportersPK int         `boil:"spaces_application_supporters_pk" json:"spaces_application_supporters_pk" toml:"spaces_application_supporters_pk" yaml:"spaces_application_supporters_pk"`
    RoleGUID                      null.String `boil:"role_guid" json:"role_guid,omitempty" toml:"role_guid" yaml:"role_guid,omitempty"`
    SpaceID                       int         `boil:"space_id" json:"space_id" toml:"space_id" yaml:"space_id"`
    UserID                        int         `boil:"user_id" json:"user_id" toml:"user_id" yaml:"user_id"`
    CreatedAt                     time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt                     time.Time   `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`

    R   *spacesApplicationSupporterR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   spacesApplicationSupporterL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSpacesApplicationSupporter

func FindSpacesApplicationSupporter(ctx context.Context, exec boil.ContextExecutor, spacesApplicationSupportersPK int, selectCols ...string) (*SpacesApplicationSupporter, error)

FindSpacesApplicationSupporter retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SpacesApplicationSupporterDeleter

type SpacesApplicationSupporterDeleter interface {
    Delete(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SpacesApplicationSupporterSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SpacesApplicationSupporterFinder

type SpacesApplicationSupporterFinder interface {
    FindSpacesApplicationSupporter(ctx context.Context, exec boil.ContextExecutor, spacesApplicationSupportersPK int, selectCols ...string) (*SpacesApplicationSupporter, error)
}

type SpacesApplicationSupporterFinisher

type SpacesApplicationSupporterFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*SpacesApplicationSupporter, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SpacesApplicationSupporterSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SpacesApplicationSupporterInserter

type SpacesApplicationSupporterInserter interface {
    Insert(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SpacesApplicationSupporterReloader

type SpacesApplicationSupporterReloader interface {
    Reload(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SpacesApplicationSupporterSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SpacesApplicationSupporterSlice

SpacesApplicationSupporterSlice is an alias for a slice of pointers to SpacesApplicationSupporter. This should almost always be used instead of []SpacesApplicationSupporter.

type SpacesApplicationSupporterSlice []*SpacesApplicationSupporter

type SpacesApplicationSupporterUpdater

type SpacesApplicationSupporterUpdater interface {
    Update(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SpacesApplicationSupporterSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SpacesApplicationSupporterUpserter

type SpacesApplicationSupporterUpserter interface {
    Upsert(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type SpacesAuditor

SpacesAuditor is an object representing the database table.

type SpacesAuditor struct {
    SpaceID          int         `boil:"space_id" json:"space_id" toml:"space_id" yaml:"space_id"`
    UserID           int         `boil:"user_id" json:"user_id" toml:"user_id" yaml:"user_id"`
    SpacesAuditorsPK int         `boil:"spaces_auditors_pk" json:"spaces_auditors_pk" toml:"spaces_auditors_pk" yaml:"spaces_auditors_pk"`
    RoleGUID         null.String `boil:"role_guid" json:"role_guid,omitempty" toml:"role_guid" yaml:"role_guid,omitempty"`
    CreatedAt        time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt        time.Time   `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`

    R   *spacesAuditorR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   spacesAuditorL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSpacesAuditor

func FindSpacesAuditor(ctx context.Context, exec boil.ContextExecutor, spacesAuditorsPK int, selectCols ...string) (*SpacesAuditor, error)

FindSpacesAuditor retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SpacesAuditorDeleter

type SpacesAuditorDeleter interface {
    Delete(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SpacesAuditorSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SpacesAuditorFinder

type SpacesAuditorFinder interface {
    FindSpacesAuditor(ctx context.Context, exec boil.ContextExecutor, spacesAuditorsPK int, selectCols ...string) (*SpacesAuditor, error)
}

type SpacesAuditorFinisher

type SpacesAuditorFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*SpacesAuditor, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SpacesAuditorSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SpacesAuditorInserter

type SpacesAuditorInserter interface {
    Insert(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SpacesAuditorReloader

type SpacesAuditorReloader interface {
    Reload(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SpacesAuditorSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SpacesAuditorSlice

SpacesAuditorSlice is an alias for a slice of pointers to SpacesAuditor. This should almost always be used instead of []SpacesAuditor.

type SpacesAuditorSlice []*SpacesAuditor

type SpacesAuditorUpdater

type SpacesAuditorUpdater interface {
    Update(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SpacesAuditorSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SpacesAuditorUpserter

type SpacesAuditorUpserter interface {
    Upsert(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type SpacesDeveloper

SpacesDeveloper is an object representing the database table.

type SpacesDeveloper struct {
    SpaceID            int         `boil:"space_id" json:"space_id" toml:"space_id" yaml:"space_id"`
    UserID             int         `boil:"user_id" json:"user_id" toml:"user_id" yaml:"user_id"`
    SpacesDevelopersPK int         `boil:"spaces_developers_pk" json:"spaces_developers_pk" toml:"spaces_developers_pk" yaml:"spaces_developers_pk"`
    RoleGUID           null.String `boil:"role_guid" json:"role_guid,omitempty" toml:"role_guid" yaml:"role_guid,omitempty"`
    CreatedAt          time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt          time.Time   `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`

    R   *spacesDeveloperR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   spacesDeveloperL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSpacesDeveloper

func FindSpacesDeveloper(ctx context.Context, exec boil.ContextExecutor, spacesDevelopersPK int, selectCols ...string) (*SpacesDeveloper, error)

FindSpacesDeveloper retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SpacesDeveloperDeleter

type SpacesDeveloperDeleter interface {
    Delete(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SpacesDeveloperSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SpacesDeveloperFinder

type SpacesDeveloperFinder interface {
    FindSpacesDeveloper(ctx context.Context, exec boil.ContextExecutor, spacesDevelopersPK int, selectCols ...string) (*SpacesDeveloper, error)
}

type SpacesDeveloperFinisher

type SpacesDeveloperFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*SpacesDeveloper, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SpacesDeveloperSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SpacesDeveloperInserter

type SpacesDeveloperInserter interface {
    Insert(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SpacesDeveloperReloader

type SpacesDeveloperReloader interface {
    Reload(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SpacesDeveloperSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SpacesDeveloperSlice

SpacesDeveloperSlice is an alias for a slice of pointers to SpacesDeveloper. This should almost always be used instead of []SpacesDeveloper.

type SpacesDeveloperSlice []*SpacesDeveloper

type SpacesDeveloperUpdater

type SpacesDeveloperUpdater interface {
    Update(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SpacesDeveloperSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SpacesDeveloperUpserter

type SpacesDeveloperUpserter interface {
    Upsert(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type SpacesManager

SpacesManager is an object representing the database table.

type SpacesManager struct {
    SpaceID          int         `boil:"space_id" json:"space_id" toml:"space_id" yaml:"space_id"`
    UserID           int         `boil:"user_id" json:"user_id" toml:"user_id" yaml:"user_id"`
    SpacesManagersPK int         `boil:"spaces_managers_pk" json:"spaces_managers_pk" toml:"spaces_managers_pk" yaml:"spaces_managers_pk"`
    RoleGUID         null.String `boil:"role_guid" json:"role_guid,omitempty" toml:"role_guid" yaml:"role_guid,omitempty"`
    CreatedAt        time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt        time.Time   `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`

    R   *spacesManagerR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   spacesManagerL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindSpacesManager

func FindSpacesManager(ctx context.Context, exec boil.ContextExecutor, spacesManagersPK int, selectCols ...string) (*SpacesManager, error)

FindSpacesManager retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type SpacesManagerDeleter

type SpacesManagerDeleter interface {
    Delete(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o SpacesManagerSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type SpacesManagerFinder

type SpacesManagerFinder interface {
    FindSpacesManager(ctx context.Context, exec boil.ContextExecutor, spacesManagersPK int, selectCols ...string) (*SpacesManager, error)
}

type SpacesManagerFinisher

type SpacesManagerFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*SpacesManager, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (SpacesManagerSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type SpacesManagerInserter

type SpacesManagerInserter interface {
    Insert(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type SpacesManagerReloader

type SpacesManagerReloader interface {
    Reload(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *SpacesManagerSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type SpacesManagerSlice

SpacesManagerSlice is an alias for a slice of pointers to SpacesManager. This should almost always be used instead of []SpacesManager.

type SpacesManagerSlice []*SpacesManager

type SpacesManagerUpdater

type SpacesManagerUpdater interface {
    Update(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o SpacesManagerSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type SpacesManagerUpserter

type SpacesManagerUpserter interface {
    Upsert(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Stack

Stack is an object representing the database table.

type Stack struct {
    ID          int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID        string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt   time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt   null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name        string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    Description null.String `boil:"description" json:"description,omitempty" toml:"description" yaml:"description,omitempty"`

    R   *stackR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   stackL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindStack

func FindStack(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Stack, error)

FindStack retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type StackAnnotation

StackAnnotation is an object representing the database table.

type StackAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *stackAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   stackAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindStackAnnotation

func FindStackAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*StackAnnotation, error)

FindStackAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type StackAnnotationDeleter

type StackAnnotationDeleter interface {
    Delete(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o StackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type StackAnnotationFinder

type StackAnnotationFinder interface {
    FindStackAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*StackAnnotation, error)
}

type StackAnnotationFinisher

type StackAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*StackAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (StackAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type StackAnnotationInserter

type StackAnnotationInserter interface {
    Insert(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type StackAnnotationReloader

type StackAnnotationReloader interface {
    Reload(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *StackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type StackAnnotationSlice

StackAnnotationSlice is an alias for a slice of pointers to StackAnnotation. This should almost always be used instead of []StackAnnotation.

type StackAnnotationSlice []*StackAnnotation

type StackAnnotationUpdater

type StackAnnotationUpdater interface {
    Update(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o StackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type StackAnnotationUpserter

type StackAnnotationUpserter interface {
    Upsert(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type StackDeleter

type StackDeleter interface {
    Delete(o *Stack, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o StackSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type StackFinder

type StackFinder interface {
    FindStack(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Stack, error)
}

type StackFinisher

type StackFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Stack, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (StackSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type StackInserter

type StackInserter interface {
    Insert(o *Stack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type StackLabel

StackLabel is an object representing the database table.

type StackLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *stackLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   stackLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindStackLabel

func FindStackLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*StackLabel, error)

FindStackLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type StackLabelDeleter

type StackLabelDeleter interface {
    Delete(o *StackLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o StackLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type StackLabelFinder

type StackLabelFinder interface {
    FindStackLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*StackLabel, error)
}

type StackLabelFinisher

type StackLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*StackLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (StackLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type StackLabelInserter

type StackLabelInserter interface {
    Insert(o *StackLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type StackLabelReloader

type StackLabelReloader interface {
    Reload(o *StackLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *StackLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type StackLabelSlice

StackLabelSlice is an alias for a slice of pointers to StackLabel. This should almost always be used instead of []StackLabel.

type StackLabelSlice []*StackLabel

type StackLabelUpdater

type StackLabelUpdater interface {
    Update(o *StackLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o StackLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type StackLabelUpserter

type StackLabelUpserter interface {
    Upsert(o *StackLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type StackReloader

type StackReloader interface {
    Reload(o *Stack, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *StackSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type StackSlice

StackSlice is an alias for a slice of pointers to Stack. This should almost always be used instead of []Stack.

type StackSlice []*Stack

type StackUpdater

type StackUpdater interface {
    Update(o *Stack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o StackSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type StackUpserter

type StackUpserter interface {
    Upsert(o *Stack, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type StagingSecurityGroupsSpace

StagingSecurityGroupsSpace is an object representing the database table.

type StagingSecurityGroupsSpace struct {
    StagingSecurityGroupID        int `boil:"staging_security_group_id" json:"staging_security_group_id" toml:"staging_security_group_id" yaml:"staging_security_group_id"`
    StagingSpaceID                int `boil:"staging_space_id" json:"staging_space_id" toml:"staging_space_id" yaml:"staging_space_id"`
    StagingSecurityGroupsSpacesPK int `boil:"staging_security_groups_spaces_pk" json:"staging_security_groups_spaces_pk" toml:"staging_security_groups_spaces_pk" yaml:"staging_security_groups_spaces_pk"`

    R   *stagingSecurityGroupsSpaceR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   stagingSecurityGroupsSpaceL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindStagingSecurityGroupsSpace

func FindStagingSecurityGroupsSpace(ctx context.Context, exec boil.ContextExecutor, stagingSecurityGroupsSpacesPK int, selectCols ...string) (*StagingSecurityGroupsSpace, error)

FindStagingSecurityGroupsSpace retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type StagingSecurityGroupsSpaceDeleter

type StagingSecurityGroupsSpaceDeleter interface {
    Delete(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o StagingSecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type StagingSecurityGroupsSpaceFinder

type StagingSecurityGroupsSpaceFinder interface {
    FindStagingSecurityGroupsSpace(ctx context.Context, exec boil.ContextExecutor, stagingSecurityGroupsSpacesPK int, selectCols ...string) (*StagingSecurityGroupsSpace, error)
}

type StagingSecurityGroupsSpaceFinisher

type StagingSecurityGroupsSpaceFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*StagingSecurityGroupsSpace, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (StagingSecurityGroupsSpaceSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type StagingSecurityGroupsSpaceInserter

type StagingSecurityGroupsSpaceInserter interface {
    Insert(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type StagingSecurityGroupsSpaceReloader

type StagingSecurityGroupsSpaceReloader interface {
    Reload(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *StagingSecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type StagingSecurityGroupsSpaceSlice

StagingSecurityGroupsSpaceSlice is an alias for a slice of pointers to StagingSecurityGroupsSpace. This should almost always be used instead of []StagingSecurityGroupsSpace.

type StagingSecurityGroupsSpaceSlice []*StagingSecurityGroupsSpace

type StagingSecurityGroupsSpaceUpdater

type StagingSecurityGroupsSpaceUpdater interface {
    Update(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o StagingSecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type StagingSecurityGroupsSpaceUpserter

type StagingSecurityGroupsSpaceUpserter interface {
    Upsert(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type Subquery

type Subquery struct {
    *queries.Query
}

func NewSubquery

func NewSubquery(mods ...qm.QueryMod) *Subquery

NewSubquery initializes a new Subquery using the passed in QueryMods to be used as part of a larger Query

func (*Subquery) SQL

func (s *Subquery) SQL() (string, []interface{})

type Task

Task is an object representing the database table.

type Task struct {
    ID                            int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID                          string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt                     time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt                     null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    Name                          string      `boil:"name" json:"name" toml:"name" yaml:"name"`
    Command                       string      `boil:"command" json:"command" toml:"command" yaml:"command"`
    State                         string      `boil:"state" json:"state" toml:"state" yaml:"state"`
    MemoryInMB                    null.Int    `boil:"memory_in_mb" json:"memory_in_mb,omitempty" toml:"memory_in_mb" yaml:"memory_in_mb,omitempty"`
    EncryptedEnvironmentVariables null.String `boil:"encrypted_environment_variables" json:"encrypted_environment_variables,omitempty" toml:"encrypted_environment_variables" yaml:"encrypted_environment_variables,omitempty"`
    Salt                          null.String `boil:"salt" json:"salt,omitempty" toml:"salt" yaml:"salt,omitempty"`
    FailureReason                 null.String `boil:"failure_reason" json:"failure_reason,omitempty" toml:"failure_reason" yaml:"failure_reason,omitempty"`
    AppGUID                       string      `boil:"app_guid" json:"app_guid" toml:"app_guid" yaml:"app_guid"`
    DropletGUID                   string      `boil:"droplet_guid" json:"droplet_guid" toml:"droplet_guid" yaml:"droplet_guid"`
    SequenceID                    null.Int    `boil:"sequence_id" json:"sequence_id,omitempty" toml:"sequence_id" yaml:"sequence_id,omitempty"`
    DiskInMB                      null.Int    `boil:"disk_in_mb" json:"disk_in_mb,omitempty" toml:"disk_in_mb" yaml:"disk_in_mb,omitempty"`
    EncryptionKeyLabel            null.String `boil:"encryption_key_label" json:"encryption_key_label,omitempty" toml:"encryption_key_label" yaml:"encryption_key_label,omitempty"`
    EncryptionIterations          int         `boil:"encryption_iterations" json:"encryption_iterations" toml:"encryption_iterations" yaml:"encryption_iterations"`

    R   *taskR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   taskL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindTask

func FindTask(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Task, error)

FindTask retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type TaskAnnotation

TaskAnnotation is an object representing the database table.

type TaskAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *taskAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   taskAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindTaskAnnotation

func FindTaskAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*TaskAnnotation, error)

FindTaskAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type TaskAnnotationDeleter

type TaskAnnotationDeleter interface {
    Delete(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o TaskAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type TaskAnnotationFinder

type TaskAnnotationFinder interface {
    FindTaskAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*TaskAnnotation, error)
}

type TaskAnnotationFinisher

type TaskAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*TaskAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (TaskAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type TaskAnnotationInserter

type TaskAnnotationInserter interface {
    Insert(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type TaskAnnotationReloader

type TaskAnnotationReloader interface {
    Reload(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *TaskAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type TaskAnnotationSlice

TaskAnnotationSlice is an alias for a slice of pointers to TaskAnnotation. This should almost always be used instead of []TaskAnnotation.

type TaskAnnotationSlice []*TaskAnnotation

type TaskAnnotationUpdater

type TaskAnnotationUpdater interface {
    Update(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o TaskAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type TaskAnnotationUpserter

type TaskAnnotationUpserter interface {
    Upsert(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type TaskDeleter

type TaskDeleter interface {
    Delete(o *Task, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o TaskSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type TaskFinder

type TaskFinder interface {
    FindTask(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Task, error)
}

type TaskFinisher

type TaskFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*Task, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (TaskSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type TaskInserter

type TaskInserter interface {
    Insert(o *Task, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type TaskLabel

TaskLabel is an object representing the database table.

type TaskLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *taskLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   taskLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindTaskLabel

func FindTaskLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*TaskLabel, error)

FindTaskLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type TaskLabelDeleter

type TaskLabelDeleter interface {
    Delete(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o TaskLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type TaskLabelFinder

type TaskLabelFinder interface {
    FindTaskLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*TaskLabel, error)
}

type TaskLabelFinisher

type TaskLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*TaskLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (TaskLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type TaskLabelInserter

type TaskLabelInserter interface {
    Insert(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type TaskLabelReloader

type TaskLabelReloader interface {
    Reload(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *TaskLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type TaskLabelSlice

TaskLabelSlice is an alias for a slice of pointers to TaskLabel. This should almost always be used instead of []TaskLabel.

type TaskLabelSlice []*TaskLabel

type TaskLabelUpdater

type TaskLabelUpdater interface {
    Update(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o TaskLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type TaskLabelUpserter

type TaskLabelUpserter interface {
    Upsert(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type TaskReloader

type TaskReloader interface {
    Reload(o *Task, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *TaskSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type TaskSlice

TaskSlice is an alias for a slice of pointers to Task. This should almost always be used instead of []Task.

type TaskSlice []*Task

type TaskUpdater

type TaskUpdater interface {
    Update(o *Task, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o TaskSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type TaskUpserter

type TaskUpserter interface {
    Upsert(o *Task, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type User

User is an object representing the database table.

type User struct {
    ID             int       `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID           string    `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt      time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt      null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    DefaultSpaceID null.Int  `boil:"default_space_id" json:"default_space_id,omitempty" toml:"default_space_id" yaml:"default_space_id,omitempty"`
    Admin          null.Bool `boil:"admin" json:"admin,omitempty" toml:"admin" yaml:"admin,omitempty"`
    Active         null.Bool `boil:"active" json:"active,omitempty" toml:"active" yaml:"active,omitempty"`
    IsOauthClient  null.Bool `boil:"is_oauth_client" json:"is_oauth_client,omitempty" toml:"is_oauth_client" yaml:"is_oauth_client,omitempty"`

    R   *userR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   userL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindUser

func FindUser(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*User, error)

FindUser retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type UserAnnotation

UserAnnotation is an object representing the database table.

type UserAnnotation struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    Key          null.String `boil:"key" json:"key,omitempty" toml:"key" yaml:"key,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *userAnnotationR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   userAnnotationL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindUserAnnotation

func FindUserAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*UserAnnotation, error)

FindUserAnnotation retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type UserAnnotationDeleter

type UserAnnotationDeleter interface {
    Delete(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o UserAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type UserAnnotationFinder

type UserAnnotationFinder interface {
    FindUserAnnotation(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*UserAnnotation, error)
}

type UserAnnotationFinisher

type UserAnnotationFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*UserAnnotation, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (UserAnnotationSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type UserAnnotationInserter

type UserAnnotationInserter interface {
    Insert(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type UserAnnotationReloader

type UserAnnotationReloader interface {
    Reload(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *UserAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type UserAnnotationSlice

UserAnnotationSlice is an alias for a slice of pointers to UserAnnotation. This should almost always be used instead of []UserAnnotation.

type UserAnnotationSlice []*UserAnnotation

type UserAnnotationUpdater

type UserAnnotationUpdater interface {
    Update(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o UserAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type UserAnnotationUpserter

type UserAnnotationUpserter interface {
    Upsert(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type UserDeleter

type UserDeleter interface {
    Delete(o *User, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o UserSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type UserFinder

type UserFinder interface {
    FindUser(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*User, error)
}

type UserFinisher

type UserFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*User, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (UserSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type UserInserter

type UserInserter interface {
    Insert(o *User, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type UserLabel

UserLabel is an object representing the database table.

type UserLabel struct {
    ID           int         `boil:"id" json:"id" toml:"id" yaml:"id"`
    GUID         string      `boil:"guid" json:"guid" toml:"guid" yaml:"guid"`
    CreatedAt    time.Time   `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
    UpdatedAt    null.Time   `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"`
    ResourceGUID null.String `boil:"resource_guid" json:"resource_guid,omitempty" toml:"resource_guid" yaml:"resource_guid,omitempty"`
    KeyPrefix    null.String `boil:"key_prefix" json:"key_prefix,omitempty" toml:"key_prefix" yaml:"key_prefix,omitempty"`
    KeyName      null.String `boil:"key_name" json:"key_name,omitempty" toml:"key_name" yaml:"key_name,omitempty"`
    Value        null.String `boil:"value" json:"value,omitempty" toml:"value" yaml:"value,omitempty"`

    R   *userLabelR `boil:"-" json:"-" toml:"-" yaml:"-"`
    L   userLabelL  `boil:"-" json:"-" toml:"-" yaml:"-"`
}

func FindUserLabel

func FindUserLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*UserLabel, error)

FindUserLabel retrieves a single record by ID with an executor. If selectCols is empty Find will return all columns.

type UserLabelDeleter

type UserLabelDeleter interface {
    Delete(o *UserLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    DeleteAllSlice(o UserLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)
}

type UserLabelFinder

type UserLabelFinder interface {
    FindUserLabel(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*UserLabel, error)
}

type UserLabelFinisher

type UserLabelFinisher interface {
    One(ctx context.Context, exec boil.ContextExecutor) (*UserLabel, error)
    Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)
    All(ctx context.Context, exec boil.ContextExecutor) (UserLabelSlice, error)
    Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)
}

type UserLabelInserter

type UserLabelInserter interface {
    Insert(o *UserLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error
}

type UserLabelReloader

type UserLabelReloader interface {
    Reload(o *UserLabel, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *UserLabelSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type UserLabelSlice

UserLabelSlice is an alias for a slice of pointers to UserLabel. This should almost always be used instead of []UserLabel.

type UserLabelSlice []*UserLabel

type UserLabelUpdater

type UserLabelUpdater interface {
    Update(o *UserLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o UserLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type UserLabelUpserter

type UserLabelUpserter interface {
    Upsert(o *UserLabel, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type UserReloader

type UserReloader interface {
    Reload(o *User, ctx context.Context, exec boil.ContextExecutor) error
    ReloadAll(o *UserSlice, ctx context.Context, exec boil.ContextExecutor) error
}

type UserSlice

UserSlice is an alias for a slice of pointers to User. This should almost always be used instead of []User.

type UserSlice []*User

type UserUpdater

type UserUpdater interface {
    Update(o *User, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)
    UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
    UpdateAllSlice(o UserSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)
}

type UserUpserter

type UserUpserter interface {
    Upsert(o *User, ctx context.Context, exec boil.ContextExecutor, updateColumns, insertColumns boil.Columns) error
}

type appAnnotationL

appAnnotationL is where Load methods for each relationship are stored.

type appAnnotationL struct{}

func (appAnnotationL) LoadResource

func (appAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeAppAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type appAnnotationQuery

type appAnnotationQuery struct {
    *queries.Query
}

func AppAnnotations

func AppAnnotations(mods ...qm.QueryMod) appAnnotationQuery

AppAnnotations retrieves all the records using an executor.

func (appAnnotationQuery) All

func (q appAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (AppAnnotationSlice, error)

All returns all AppAnnotation records from the query.

func (appAnnotationQuery) Count

func (q appAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all AppAnnotation records in the query.

func (appAnnotationQuery) Delete

func (q appAnnotationQuery) Delete(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single AppAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (appAnnotationQuery) DeleteAll

func (q appAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (appAnnotationQuery) DeleteAllSlice

func (q appAnnotationQuery) DeleteAllSlice(o AppAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (appAnnotationQuery) Exists

func (q appAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (appAnnotationQuery) Insert

func (q appAnnotationQuery) Insert(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (appAnnotationQuery) One

func (q appAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*AppAnnotation, error)

One returns a single appAnnotation record from the query.

func (appAnnotationQuery) Reload

func (q appAnnotationQuery) Reload(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (appAnnotationQuery) ReloadAll

func (q appAnnotationQuery) ReloadAll(o *AppAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (appAnnotationQuery) RemoveResource

func (q appAnnotationQuery) RemoveResource(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor, related *App) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (appAnnotationQuery) Resource

func (q appAnnotationQuery) Resource(o *AppAnnotation, mods ...qm.QueryMod) appQuery

Resource pointed to by the foreign key.

func (appAnnotationQuery) SetResource

func (q appAnnotationQuery) SetResource(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetResource of the appAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceAppAnnotations.

func (appAnnotationQuery) Update

func (q appAnnotationQuery) Update(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the AppAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (appAnnotationQuery) UpdateAll

func (q appAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (appAnnotationQuery) UpdateAllSlice

func (q appAnnotationQuery) UpdateAllSlice(o AppAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (appAnnotationQuery) Upsert

func (q appAnnotationQuery) Upsert(o *AppAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type appAnnotationR

appAnnotationR is where relationships are stored.

type appAnnotationR struct {
    Resource *App `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*appAnnotationR) NewStruct

func (*appAnnotationR) NewStruct() *appAnnotationR

NewStruct creates a new relationship struct

type appEventL

appEventL is where Load methods for each relationship are stored.

type appEventL struct{}

func (appEventL) LoadApp

func (appEventL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybeAppEvent interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type appEventQuery

type appEventQuery struct {
    *queries.Query
}

func AppEvents

func AppEvents(mods ...qm.QueryMod) appEventQuery

AppEvents retrieves all the records using an executor.

func (appEventQuery) All

func (q appEventQuery) All(ctx context.Context, exec boil.ContextExecutor) (AppEventSlice, error)

All returns all AppEvent records from the query.

func (appEventQuery) App

func (q appEventQuery) App(o *AppEvent, mods ...qm.QueryMod) processQuery

App pointed to by the foreign key.

func (appEventQuery) Count

func (q appEventQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all AppEvent records in the query.

func (appEventQuery) Delete

func (q appEventQuery) Delete(o *AppEvent, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single AppEvent record with an executor. Delete will match against the primary key column to find the record to delete.

func (appEventQuery) DeleteAll

func (q appEventQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (appEventQuery) DeleteAllSlice

func (q appEventQuery) DeleteAllSlice(o AppEventSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (appEventQuery) Exists

func (q appEventQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (appEventQuery) Insert

func (q appEventQuery) Insert(o *AppEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (appEventQuery) One

func (q appEventQuery) One(ctx context.Context, exec boil.ContextExecutor) (*AppEvent, error)

One returns a single appEvent record from the query.

func (appEventQuery) Reload

func (q appEventQuery) Reload(o *AppEvent, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (appEventQuery) ReloadAll

func (q appEventQuery) ReloadAll(o *AppEventSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (appEventQuery) SetApp

func (q appEventQuery) SetApp(o *AppEvent, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Process) error

SetApp of the appEvent to the related item. Sets o.R.App to related. Adds o to related.R.AppAppEvents.

func (appEventQuery) Update

func (q appEventQuery) Update(o *AppEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the AppEvent. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (appEventQuery) UpdateAll

func (q appEventQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (appEventQuery) UpdateAllSlice

func (q appEventQuery) UpdateAllSlice(o AppEventSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (appEventQuery) Upsert

func (q appEventQuery) Upsert(o *AppEvent, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type appEventR

appEventR is where relationships are stored.

type appEventR struct {
    App *Process `boil:"App" json:"App" toml:"App" yaml:"App"`
}

func (*appEventR) NewStruct

func (*appEventR) NewStruct() *appEventR

NewStruct creates a new relationship struct

type appL

appL is where Load methods for each relationship are stored.

type appL struct{}

func (appL) LoadBuilds

func (appL) LoadBuilds(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadBuilds allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadDeployments

func (appL) LoadDeployments(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadDeployments allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadDroplets

func (appL) LoadDroplets(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadDroplets allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadKpackLifecycleData

func (appL) LoadKpackLifecycleData(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadKpackLifecycleData allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadPackages

func (appL) LoadPackages(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadPackages allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadProcesses

func (appL) LoadProcesses(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadProcesses allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadResourceAppAnnotations

func (appL) LoadResourceAppAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadResourceAppAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadResourceAppLabels

func (appL) LoadResourceAppLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadResourceAppLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadRevisions

func (appL) LoadRevisions(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadRevisions allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadRouteMappings

func (appL) LoadRouteMappings(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadRouteMappings allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadServiceBindings

func (appL) LoadServiceBindings(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadServiceBindings allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadSidecars

func (appL) LoadSidecars(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadSidecars allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (appL) LoadSpace

func (appL) LoadSpace(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadSpace allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (appL) LoadTasks

func (appL) LoadTasks(ctx context.Context, e boil.ContextExecutor, singular bool, maybeApp interface{}, mods queries.Applicator) error

LoadTasks allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type appLabelL

appLabelL is where Load methods for each relationship are stored.

type appLabelL struct{}

func (appLabelL) LoadResource

func (appLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeAppLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type appLabelQuery

type appLabelQuery struct {
    *queries.Query
}

func AppLabels

func AppLabels(mods ...qm.QueryMod) appLabelQuery

AppLabels retrieves all the records using an executor.

func (appLabelQuery) All

func (q appLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (AppLabelSlice, error)

All returns all AppLabel records from the query.

func (appLabelQuery) Count

func (q appLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all AppLabel records in the query.

func (appLabelQuery) Delete

func (q appLabelQuery) Delete(o *AppLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single AppLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (appLabelQuery) DeleteAll

func (q appLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (appLabelQuery) DeleteAllSlice

func (q appLabelQuery) DeleteAllSlice(o AppLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (appLabelQuery) Exists

func (q appLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (appLabelQuery) Insert

func (q appLabelQuery) Insert(o *AppLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (appLabelQuery) One

func (q appLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*AppLabel, error)

One returns a single appLabel record from the query.

func (appLabelQuery) Reload

func (q appLabelQuery) Reload(o *AppLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (appLabelQuery) ReloadAll

func (q appLabelQuery) ReloadAll(o *AppLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (appLabelQuery) RemoveResource

func (q appLabelQuery) RemoveResource(o *AppLabel, ctx context.Context, exec boil.ContextExecutor, related *App) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (appLabelQuery) Resource

func (q appLabelQuery) Resource(o *AppLabel, mods ...qm.QueryMod) appQuery

Resource pointed to by the foreign key.

func (appLabelQuery) SetResource

func (q appLabelQuery) SetResource(o *AppLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetResource of the appLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceAppLabels.

func (appLabelQuery) Update

func (q appLabelQuery) Update(o *AppLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the AppLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (appLabelQuery) UpdateAll

func (q appLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (appLabelQuery) UpdateAllSlice

func (q appLabelQuery) UpdateAllSlice(o AppLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (appLabelQuery) Upsert

func (q appLabelQuery) Upsert(o *AppLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type appLabelR

appLabelR is where relationships are stored.

type appLabelR struct {
    Resource *App `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*appLabelR) NewStruct

func (*appLabelR) NewStruct() *appLabelR

NewStruct creates a new relationship struct

type appQuery

type appQuery struct {
    *queries.Query
}

func Apps

func Apps(mods ...qm.QueryMod) appQuery

Apps retrieves all the records using an executor.

func (appQuery) AddBuilds

func (q appQuery) AddBuilds(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Build) error

AddBuilds adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.Builds. Sets related.R.App appropriately.

func (appQuery) AddDeployments

func (q appQuery) AddDeployments(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Deployment) error

AddDeployments adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.Deployments. Sets related.R.App appropriately.

func (appQuery) AddDroplets

func (q appQuery) AddDroplets(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Droplet) error

AddDroplets adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.Droplets. Sets related.R.App appropriately.

func (appQuery) AddKpackLifecycleData

func (q appQuery) AddKpackLifecycleData(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*KpackLifecycleDatum) error

AddKpackLifecycleData adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.KpackLifecycleData. Sets related.R.App appropriately.

func (appQuery) AddPackages

func (q appQuery) AddPackages(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Package) error

AddPackages adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.Packages. Sets related.R.App appropriately.

func (appQuery) AddProcesses

func (q appQuery) AddProcesses(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Process) error

AddProcesses adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.Processes. Sets related.R.App appropriately.

func (appQuery) AddResourceAppAnnotations

func (q appQuery) AddResourceAppAnnotations(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*AppAnnotation) error

AddResourceAppAnnotations adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.ResourceAppAnnotations. Sets related.R.Resource appropriately.

func (appQuery) AddResourceAppLabels

func (q appQuery) AddResourceAppLabels(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*AppLabel) error

AddResourceAppLabels adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.ResourceAppLabels. Sets related.R.Resource appropriately.

func (appQuery) AddRevisions

func (q appQuery) AddRevisions(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Revision) error

AddRevisions adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.Revisions. Sets related.R.App appropriately.

func (appQuery) AddRouteMappings

func (q appQuery) AddRouteMappings(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteMapping) error

AddRouteMappings adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.RouteMappings. Sets related.R.App appropriately.

func (appQuery) AddServiceBindings

func (q appQuery) AddServiceBindings(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBinding) error

AddServiceBindings adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.ServiceBindings. Sets related.R.App appropriately.

func (appQuery) AddSidecars

func (q appQuery) AddSidecars(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Sidecar) error

AddSidecars adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.Sidecars. Sets related.R.App appropriately.

func (appQuery) AddTasks

func (q appQuery) AddTasks(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Task) error

AddTasks adds the given related objects to the existing relationships of the app\, optionally inserting them as new records. Appends related to o.R.Tasks. Sets related.R.App appropriately.

func (appQuery) All

func (q appQuery) All(ctx context.Context, exec boil.ContextExecutor) (AppSlice, error)

All returns all App records from the query.

func (appQuery) Builds

func (q appQuery) Builds(o *App, mods ...qm.QueryMod) buildQuery

Builds retrieves all the build's Builds with an executor.

func (appQuery) Count

func (q appQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all App records in the query.

func (appQuery) Delete

func (q appQuery) Delete(o *App, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single App record with an executor. Delete will match against the primary key column to find the record to delete.

func (appQuery) DeleteAll

func (q appQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (appQuery) DeleteAllSlice

func (q appQuery) DeleteAllSlice(o AppSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (appQuery) Deployments

func (q appQuery) Deployments(o *App, mods ...qm.QueryMod) deploymentQuery

Deployments retrieves all the deployment's Deployments with an executor.

func (appQuery) Droplets

func (q appQuery) Droplets(o *App, mods ...qm.QueryMod) dropletQuery

Droplets retrieves all the droplet's Droplets with an executor.

func (appQuery) Exists

func (q appQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (appQuery) Insert

func (q appQuery) Insert(o *App, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (appQuery) KpackLifecycleData

func (q appQuery) KpackLifecycleData(o *App, mods ...qm.QueryMod) kpackLifecycleDatumQuery

KpackLifecycleData retrieves all the kpack_lifecycle_datum's KpackLifecycleData with an executor.

func (appQuery) One

func (q appQuery) One(ctx context.Context, exec boil.ContextExecutor) (*App, error)

One returns a single app record from the query.

func (appQuery) Packages

func (q appQuery) Packages(o *App, mods ...qm.QueryMod) packageQuery

Packages retrieves all the package's Packages with an executor.

func (appQuery) Processes

func (q appQuery) Processes(o *App, mods ...qm.QueryMod) processQuery

Processes retrieves all the process's Processes with an executor.

func (appQuery) Reload

func (q appQuery) Reload(o *App, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (appQuery) ReloadAll

func (q appQuery) ReloadAll(o *AppSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (appQuery) RemoveBuilds

func (q appQuery) RemoveBuilds(o *App, ctx context.Context, exec boil.ContextExecutor, related ...*Build) error

RemoveBuilds relationships from objects passed in. Removes related items from R.Builds (uses pointer comparison\, removal does not keep order) Sets related.R.App.

func (appQuery) RemoveDeployments

func (q appQuery) RemoveDeployments(o *App, ctx context.Context, exec boil.ContextExecutor, related ...*Deployment) error

RemoveDeployments relationships from objects passed in. Removes related items from R.Deployments (uses pointer comparison\, removal does not keep order) Sets related.R.App.

func (appQuery) RemoveDroplets

func (q appQuery) RemoveDroplets(o *App, ctx context.Context, exec boil.ContextExecutor, related ...*Droplet) error

RemoveDroplets relationships from objects passed in. Removes related items from R.Droplets (uses pointer comparison\, removal does not keep order) Sets related.R.App.

func (appQuery) RemoveKpackLifecycleData

func (q appQuery) RemoveKpackLifecycleData(o *App, ctx context.Context, exec boil.ContextExecutor, related ...*KpackLifecycleDatum) error

RemoveKpackLifecycleData relationships from objects passed in. Removes related items from R.KpackLifecycleData (uses pointer comparison\, removal does not keep order) Sets related.R.App.

func (appQuery) RemovePackages

func (q appQuery) RemovePackages(o *App, ctx context.Context, exec boil.ContextExecutor, related ...*Package) error

RemovePackages relationships from objects passed in. Removes related items from R.Packages (uses pointer comparison\, removal does not keep order) Sets related.R.App.

func (appQuery) RemoveProcesses

func (q appQuery) RemoveProcesses(o *App, ctx context.Context, exec boil.ContextExecutor, related ...*Process) error

RemoveProcesses relationships from objects passed in. Removes related items from R.Processes (uses pointer comparison\, removal does not keep order) Sets related.R.App.

func (appQuery) RemoveResourceAppAnnotations

func (q appQuery) RemoveResourceAppAnnotations(o *App, ctx context.Context, exec boil.ContextExecutor, related ...*AppAnnotation) error

RemoveResourceAppAnnotations relationships from objects passed in. Removes related items from R.ResourceAppAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (appQuery) RemoveResourceAppLabels

func (q appQuery) RemoveResourceAppLabels(o *App, ctx context.Context, exec boil.ContextExecutor, related ...*AppLabel) error

RemoveResourceAppLabels relationships from objects passed in. Removes related items from R.ResourceAppLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (appQuery) RemoveRevisions

func (q appQuery) RemoveRevisions(o *App, ctx context.Context, exec boil.ContextExecutor, related ...*Revision) error

RemoveRevisions relationships from objects passed in. Removes related items from R.Revisions (uses pointer comparison\, removal does not keep order) Sets related.R.App.

func (appQuery) RemoveSpace

func (q appQuery) RemoveSpace(o *App, ctx context.Context, exec boil.ContextExecutor, related *Space) error

RemoveSpace relationship. Sets o.R.Space to nil. Removes o from all passed in related items' relationships struct (Optional).

func (appQuery) ResourceAppAnnotations

func (q appQuery) ResourceAppAnnotations(o *App, mods ...qm.QueryMod) appAnnotationQuery

ResourceAppAnnotations retrieves all the app_annotation's AppAnnotations with an executor via resource_guid column.

func (appQuery) ResourceAppLabels

func (q appQuery) ResourceAppLabels(o *App, mods ...qm.QueryMod) appLabelQuery

ResourceAppLabels retrieves all the app_label's AppLabels with an executor via resource_guid column.

func (appQuery) Revisions

func (q appQuery) Revisions(o *App, mods ...qm.QueryMod) revisionQuery

Revisions retrieves all the revision's Revisions with an executor.

func (appQuery) RouteMappings

func (q appQuery) RouteMappings(o *App, mods ...qm.QueryMod) routeMappingQuery

RouteMappings retrieves all the route_mapping's RouteMappings with an executor.

func (appQuery) ServiceBindings

func (q appQuery) ServiceBindings(o *App, mods ...qm.QueryMod) serviceBindingQuery

ServiceBindings retrieves all the service_binding's ServiceBindings with an executor.

func (appQuery) SetBuilds

func (q appQuery) SetBuilds(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Build) error

SetBuilds removes all previously related items of the app replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.App's Builds accordingly. Replaces o.R.Builds with related. Sets related.R.App's Builds accordingly.

func (appQuery) SetDeployments

func (q appQuery) SetDeployments(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Deployment) error

SetDeployments removes all previously related items of the app replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.App's Deployments accordingly. Replaces o.R.Deployments with related. Sets related.R.App's Deployments accordingly.

func (appQuery) SetDroplets

func (q appQuery) SetDroplets(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Droplet) error

SetDroplets removes all previously related items of the app replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.App's Droplets accordingly. Replaces o.R.Droplets with related. Sets related.R.App's Droplets accordingly.

func (appQuery) SetKpackLifecycleData

func (q appQuery) SetKpackLifecycleData(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*KpackLifecycleDatum) error

SetKpackLifecycleData removes all previously related items of the app replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.App's KpackLifecycleData accordingly. Replaces o.R.KpackLifecycleData with related. Sets related.R.App's KpackLifecycleData accordingly.

func (appQuery) SetPackages

func (q appQuery) SetPackages(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Package) error

SetPackages removes all previously related items of the app replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.App's Packages accordingly. Replaces o.R.Packages with related. Sets related.R.App's Packages accordingly.

func (appQuery) SetProcesses

func (q appQuery) SetProcesses(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Process) error

SetProcesses removes all previously related items of the app replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.App's Processes accordingly. Replaces o.R.Processes with related. Sets related.R.App's Processes accordingly.

func (appQuery) SetResourceAppAnnotations

func (q appQuery) SetResourceAppAnnotations(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*AppAnnotation) error

SetResourceAppAnnotations removes all previously related items of the app replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceAppAnnotations accordingly. Replaces o.R.ResourceAppAnnotations with related. Sets related.R.Resource's ResourceAppAnnotations accordingly.

func (appQuery) SetResourceAppLabels

func (q appQuery) SetResourceAppLabels(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*AppLabel) error

SetResourceAppLabels removes all previously related items of the app replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceAppLabels accordingly. Replaces o.R.ResourceAppLabels with related. Sets related.R.Resource's ResourceAppLabels accordingly.

func (appQuery) SetRevisions

func (q appQuery) SetRevisions(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Revision) error

SetRevisions removes all previously related items of the app replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.App's Revisions accordingly. Replaces o.R.Revisions with related. Sets related.R.App's Revisions accordingly.

func (appQuery) SetSpace

func (q appQuery) SetSpace(o *App, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetSpace of the app to the related item. Sets o.R.Space to related. Adds o to related.R.Apps.

func (appQuery) Sidecars

func (q appQuery) Sidecars(o *App, mods ...qm.QueryMod) sidecarQuery

Sidecars retrieves all the sidecar's Sidecars with an executor.

func (appQuery) Space

func (q appQuery) Space(o *App, mods ...qm.QueryMod) spaceQuery

Space pointed to by the foreign key.

func (appQuery) Tasks

func (q appQuery) Tasks(o *App, mods ...qm.QueryMod) taskQuery

Tasks retrieves all the task's Tasks with an executor.

func (appQuery) Update

func (q appQuery) Update(o *App, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the App. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (appQuery) UpdateAll

func (q appQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (appQuery) UpdateAllSlice

func (q appQuery) UpdateAllSlice(o AppSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (appQuery) Upsert

func (q appQuery) Upsert(o *App, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type appR

appR is where relationships are stored.

type appR struct {
    Space                  *Space                   `boil:"Space" json:"Space" toml:"Space" yaml:"Space"`
    ResourceAppAnnotations AppAnnotationSlice       `boil:"ResourceAppAnnotations" json:"ResourceAppAnnotations" toml:"ResourceAppAnnotations" yaml:"ResourceAppAnnotations"`
    ResourceAppLabels      AppLabelSlice            `boil:"ResourceAppLabels" json:"ResourceAppLabels" toml:"ResourceAppLabels" yaml:"ResourceAppLabels"`
    Builds                 BuildSlice               `boil:"Builds" json:"Builds" toml:"Builds" yaml:"Builds"`
    Deployments            DeploymentSlice          `boil:"Deployments" json:"Deployments" toml:"Deployments" yaml:"Deployments"`
    Droplets               DropletSlice             `boil:"Droplets" json:"Droplets" toml:"Droplets" yaml:"Droplets"`
    KpackLifecycleData     KpackLifecycleDatumSlice `boil:"KpackLifecycleData" json:"KpackLifecycleData" toml:"KpackLifecycleData" yaml:"KpackLifecycleData"`
    Packages               PackageSlice             `boil:"Packages" json:"Packages" toml:"Packages" yaml:"Packages"`
    Processes              ProcessSlice             `boil:"Processes" json:"Processes" toml:"Processes" yaml:"Processes"`
    Revisions              RevisionSlice            `boil:"Revisions" json:"Revisions" toml:"Revisions" yaml:"Revisions"`
    RouteMappings          RouteMappingSlice        `boil:"RouteMappings" json:"RouteMappings" toml:"RouteMappings" yaml:"RouteMappings"`
    ServiceBindings        ServiceBindingSlice      `boil:"ServiceBindings" json:"ServiceBindings" toml:"ServiceBindings" yaml:"ServiceBindings"`
    Sidecars               SidecarSlice             `boil:"Sidecars" json:"Sidecars" toml:"Sidecars" yaml:"Sidecars"`
    Tasks                  TaskSlice                `boil:"Tasks" json:"Tasks" toml:"Tasks" yaml:"Tasks"`
}

func (*appR) NewStruct

func (*appR) NewStruct() *appR

NewStruct creates a new relationship struct

type appUsageEventL

appUsageEventL is where Load methods for each relationship are stored.

type appUsageEventL struct{}

type appUsageEventQuery

type appUsageEventQuery struct {
    *queries.Query
}

func AppUsageEvents

func AppUsageEvents(mods ...qm.QueryMod) appUsageEventQuery

AppUsageEvents retrieves all the records using an executor.

func (appUsageEventQuery) All

func (q appUsageEventQuery) All(ctx context.Context, exec boil.ContextExecutor) (AppUsageEventSlice, error)

All returns all AppUsageEvent records from the query.

func (appUsageEventQuery) Count

func (q appUsageEventQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all AppUsageEvent records in the query.

func (appUsageEventQuery) Delete

func (q appUsageEventQuery) Delete(o *AppUsageEvent, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single AppUsageEvent record with an executor. Delete will match against the primary key column to find the record to delete.

func (appUsageEventQuery) DeleteAll

func (q appUsageEventQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (appUsageEventQuery) DeleteAllSlice

func (q appUsageEventQuery) DeleteAllSlice(o AppUsageEventSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (appUsageEventQuery) Exists

func (q appUsageEventQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (appUsageEventQuery) Insert

func (q appUsageEventQuery) Insert(o *AppUsageEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (appUsageEventQuery) One

func (q appUsageEventQuery) One(ctx context.Context, exec boil.ContextExecutor) (*AppUsageEvent, error)

One returns a single appUsageEvent record from the query.

func (appUsageEventQuery) Reload

func (q appUsageEventQuery) Reload(o *AppUsageEvent, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (appUsageEventQuery) ReloadAll

func (q appUsageEventQuery) ReloadAll(o *AppUsageEventSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (appUsageEventQuery) Update

func (q appUsageEventQuery) Update(o *AppUsageEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the AppUsageEvent. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (appUsageEventQuery) UpdateAll

func (q appUsageEventQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (appUsageEventQuery) UpdateAllSlice

func (q appUsageEventQuery) UpdateAllSlice(o AppUsageEventSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (appUsageEventQuery) Upsert

func (q appUsageEventQuery) Upsert(o *AppUsageEvent, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type appUsageEventR

appUsageEventR is where relationships are stored.

type appUsageEventR struct {
}

func (*appUsageEventR) NewStruct

func (*appUsageEventR) NewStruct() *appUsageEventR

NewStruct creates a new relationship struct

type buildAnnotationL

buildAnnotationL is where Load methods for each relationship are stored.

type buildAnnotationL struct{}

func (buildAnnotationL) LoadResource

func (buildAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuildAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type buildAnnotationQuery

type buildAnnotationQuery struct {
    *queries.Query
}

func BuildAnnotations

func BuildAnnotations(mods ...qm.QueryMod) buildAnnotationQuery

BuildAnnotations retrieves all the records using an executor.

func (buildAnnotationQuery) All

func (q buildAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (BuildAnnotationSlice, error)

All returns all BuildAnnotation records from the query.

func (buildAnnotationQuery) Count

func (q buildAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all BuildAnnotation records in the query.

func (buildAnnotationQuery) Delete

func (q buildAnnotationQuery) Delete(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single BuildAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (buildAnnotationQuery) DeleteAll

func (q buildAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (buildAnnotationQuery) DeleteAllSlice

func (q buildAnnotationQuery) DeleteAllSlice(o BuildAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (buildAnnotationQuery) Exists

func (q buildAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (buildAnnotationQuery) Insert

func (q buildAnnotationQuery) Insert(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (buildAnnotationQuery) One

func (q buildAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*BuildAnnotation, error)

One returns a single buildAnnotation record from the query.

func (buildAnnotationQuery) Reload

func (q buildAnnotationQuery) Reload(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (buildAnnotationQuery) ReloadAll

func (q buildAnnotationQuery) ReloadAll(o *BuildAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (buildAnnotationQuery) RemoveResource

func (q buildAnnotationQuery) RemoveResource(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Build) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (buildAnnotationQuery) Resource

func (q buildAnnotationQuery) Resource(o *BuildAnnotation, mods ...qm.QueryMod) buildQuery

Resource pointed to by the foreign key.

func (buildAnnotationQuery) SetResource

func (q buildAnnotationQuery) SetResource(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Build) error

SetResource of the buildAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceBuildAnnotations.

func (buildAnnotationQuery) Update

func (q buildAnnotationQuery) Update(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the BuildAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (buildAnnotationQuery) UpdateAll

func (q buildAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (buildAnnotationQuery) UpdateAllSlice

func (q buildAnnotationQuery) UpdateAllSlice(o BuildAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (buildAnnotationQuery) Upsert

func (q buildAnnotationQuery) Upsert(o *BuildAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type buildAnnotationR

buildAnnotationR is where relationships are stored.

type buildAnnotationR struct {
    Resource *Build `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*buildAnnotationR) NewStruct

func (*buildAnnotationR) NewStruct() *buildAnnotationR

NewStruct creates a new relationship struct

type buildL

buildL is where Load methods for each relationship are stored.

type buildL struct{}

func (buildL) LoadApp

func (buildL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuild interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (buildL) LoadKpackLifecycleData

func (buildL) LoadKpackLifecycleData(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuild interface{}, mods queries.Applicator) error

LoadKpackLifecycleData allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (buildL) LoadResourceBuildAnnotations

func (buildL) LoadResourceBuildAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuild interface{}, mods queries.Applicator) error

LoadResourceBuildAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (buildL) LoadResourceBuildLabels

func (buildL) LoadResourceBuildLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuild interface{}, mods queries.Applicator) error

LoadResourceBuildLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type buildLabelL

buildLabelL is where Load methods for each relationship are stored.

type buildLabelL struct{}

func (buildLabelL) LoadResource

func (buildLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuildLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type buildLabelQuery

type buildLabelQuery struct {
    *queries.Query
}

func BuildLabels

func BuildLabels(mods ...qm.QueryMod) buildLabelQuery

BuildLabels retrieves all the records using an executor.

func (buildLabelQuery) All

func (q buildLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (BuildLabelSlice, error)

All returns all BuildLabel records from the query.

func (buildLabelQuery) Count

func (q buildLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all BuildLabel records in the query.

func (buildLabelQuery) Delete

func (q buildLabelQuery) Delete(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single BuildLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (buildLabelQuery) DeleteAll

func (q buildLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (buildLabelQuery) DeleteAllSlice

func (q buildLabelQuery) DeleteAllSlice(o BuildLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (buildLabelQuery) Exists

func (q buildLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (buildLabelQuery) Insert

func (q buildLabelQuery) Insert(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (buildLabelQuery) One

func (q buildLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*BuildLabel, error)

One returns a single buildLabel record from the query.

func (buildLabelQuery) Reload

func (q buildLabelQuery) Reload(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (buildLabelQuery) ReloadAll

func (q buildLabelQuery) ReloadAll(o *BuildLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (buildLabelQuery) RemoveResource

func (q buildLabelQuery) RemoveResource(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor, related *Build) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (buildLabelQuery) Resource

func (q buildLabelQuery) Resource(o *BuildLabel, mods ...qm.QueryMod) buildQuery

Resource pointed to by the foreign key.

func (buildLabelQuery) SetResource

func (q buildLabelQuery) SetResource(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Build) error

SetResource of the buildLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceBuildLabels.

func (buildLabelQuery) Update

func (q buildLabelQuery) Update(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the BuildLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (buildLabelQuery) UpdateAll

func (q buildLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (buildLabelQuery) UpdateAllSlice

func (q buildLabelQuery) UpdateAllSlice(o BuildLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (buildLabelQuery) Upsert

func (q buildLabelQuery) Upsert(o *BuildLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type buildLabelR

buildLabelR is where relationships are stored.

type buildLabelR struct {
    Resource *Build `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*buildLabelR) NewStruct

func (*buildLabelR) NewStruct() *buildLabelR

NewStruct creates a new relationship struct

type buildQuery

type buildQuery struct {
    *queries.Query
}

func Builds

func Builds(mods ...qm.QueryMod) buildQuery

Builds retrieves all the records using an executor.

func (buildQuery) AddKpackLifecycleData

func (q buildQuery) AddKpackLifecycleData(o *Build, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*KpackLifecycleDatum) error

AddKpackLifecycleData adds the given related objects to the existing relationships of the build\, optionally inserting them as new records. Appends related to o.R.KpackLifecycleData. Sets related.R.Build appropriately.

func (buildQuery) AddResourceBuildAnnotations

func (q buildQuery) AddResourceBuildAnnotations(o *Build, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*BuildAnnotation) error

AddResourceBuildAnnotations adds the given related objects to the existing relationships of the build\, optionally inserting them as new records. Appends related to o.R.ResourceBuildAnnotations. Sets related.R.Resource appropriately.

func (buildQuery) AddResourceBuildLabels

func (q buildQuery) AddResourceBuildLabels(o *Build, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*BuildLabel) error

AddResourceBuildLabels adds the given related objects to the existing relationships of the build\, optionally inserting them as new records. Appends related to o.R.ResourceBuildLabels. Sets related.R.Resource appropriately.

func (buildQuery) All

func (q buildQuery) All(ctx context.Context, exec boil.ContextExecutor) (BuildSlice, error)

All returns all Build records from the query.

func (buildQuery) App

func (q buildQuery) App(o *Build, mods ...qm.QueryMod) appQuery

App pointed to by the foreign key.

func (buildQuery) Count

func (q buildQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Build records in the query.

func (buildQuery) Delete

func (q buildQuery) Delete(o *Build, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Build record with an executor. Delete will match against the primary key column to find the record to delete.

func (buildQuery) DeleteAll

func (q buildQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (buildQuery) DeleteAllSlice

func (q buildQuery) DeleteAllSlice(o BuildSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (buildQuery) Exists

func (q buildQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (buildQuery) Insert

func (q buildQuery) Insert(o *Build, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (buildQuery) KpackLifecycleData

func (q buildQuery) KpackLifecycleData(o *Build, mods ...qm.QueryMod) kpackLifecycleDatumQuery

KpackLifecycleData retrieves all the kpack_lifecycle_datum's KpackLifecycleData with an executor.

func (buildQuery) One

func (q buildQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Build, error)

One returns a single build record from the query.

func (buildQuery) Reload

func (q buildQuery) Reload(o *Build, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (buildQuery) ReloadAll

func (q buildQuery) ReloadAll(o *BuildSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (buildQuery) RemoveApp

func (q buildQuery) RemoveApp(o *Build, ctx context.Context, exec boil.ContextExecutor, related *App) error

RemoveApp relationship. Sets o.R.App to nil. Removes o from all passed in related items' relationships struct (Optional).

func (buildQuery) RemoveKpackLifecycleData

func (q buildQuery) RemoveKpackLifecycleData(o *Build, ctx context.Context, exec boil.ContextExecutor, related ...*KpackLifecycleDatum) error

RemoveKpackLifecycleData relationships from objects passed in. Removes related items from R.KpackLifecycleData (uses pointer comparison\, removal does not keep order) Sets related.R.Build.

func (buildQuery) RemoveResourceBuildAnnotations

func (q buildQuery) RemoveResourceBuildAnnotations(o *Build, ctx context.Context, exec boil.ContextExecutor, related ...*BuildAnnotation) error

RemoveResourceBuildAnnotations relationships from objects passed in. Removes related items from R.ResourceBuildAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (buildQuery) RemoveResourceBuildLabels

func (q buildQuery) RemoveResourceBuildLabels(o *Build, ctx context.Context, exec boil.ContextExecutor, related ...*BuildLabel) error

RemoveResourceBuildLabels relationships from objects passed in. Removes related items from R.ResourceBuildLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (buildQuery) ResourceBuildAnnotations

func (q buildQuery) ResourceBuildAnnotations(o *Build, mods ...qm.QueryMod) buildAnnotationQuery

ResourceBuildAnnotations retrieves all the build_annotation's BuildAnnotations with an executor via resource_guid column.

func (buildQuery) ResourceBuildLabels

func (q buildQuery) ResourceBuildLabels(o *Build, mods ...qm.QueryMod) buildLabelQuery

ResourceBuildLabels retrieves all the build_label's BuildLabels with an executor via resource_guid column.

func (buildQuery) SetApp

func (q buildQuery) SetApp(o *Build, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetApp of the build to the related item. Sets o.R.App to related. Adds o to related.R.Builds.

func (buildQuery) SetKpackLifecycleData

func (q buildQuery) SetKpackLifecycleData(o *Build, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*KpackLifecycleDatum) error

SetKpackLifecycleData removes all previously related items of the build replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Build's KpackLifecycleData accordingly. Replaces o.R.KpackLifecycleData with related. Sets related.R.Build's KpackLifecycleData accordingly.

func (buildQuery) SetResourceBuildAnnotations

func (q buildQuery) SetResourceBuildAnnotations(o *Build, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*BuildAnnotation) error

SetResourceBuildAnnotations removes all previously related items of the build replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceBuildAnnotations accordingly. Replaces o.R.ResourceBuildAnnotations with related. Sets related.R.Resource's ResourceBuildAnnotations accordingly.

func (buildQuery) SetResourceBuildLabels

func (q buildQuery) SetResourceBuildLabels(o *Build, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*BuildLabel) error

SetResourceBuildLabels removes all previously related items of the build replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceBuildLabels accordingly. Replaces o.R.ResourceBuildLabels with related. Sets related.R.Resource's ResourceBuildLabels accordingly.

func (buildQuery) Update

func (q buildQuery) Update(o *Build, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Build. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (buildQuery) UpdateAll

func (q buildQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (buildQuery) UpdateAllSlice

func (q buildQuery) UpdateAllSlice(o BuildSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (buildQuery) Upsert

func (q buildQuery) Upsert(o *Build, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type buildR

buildR is where relationships are stored.

type buildR struct {
    App                      *App                     `boil:"App" json:"App" toml:"App" yaml:"App"`
    ResourceBuildAnnotations BuildAnnotationSlice     `boil:"ResourceBuildAnnotations" json:"ResourceBuildAnnotations" toml:"ResourceBuildAnnotations" yaml:"ResourceBuildAnnotations"`
    ResourceBuildLabels      BuildLabelSlice          `boil:"ResourceBuildLabels" json:"ResourceBuildLabels" toml:"ResourceBuildLabels" yaml:"ResourceBuildLabels"`
    KpackLifecycleData       KpackLifecycleDatumSlice `boil:"KpackLifecycleData" json:"KpackLifecycleData" toml:"KpackLifecycleData" yaml:"KpackLifecycleData"`
}

func (*buildR) NewStruct

func (*buildR) NewStruct() *buildR

NewStruct creates a new relationship struct

type buildpackAnnotationL

buildpackAnnotationL is where Load methods for each relationship are stored.

type buildpackAnnotationL struct{}

func (buildpackAnnotationL) LoadResource

func (buildpackAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuildpackAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type buildpackAnnotationQuery

type buildpackAnnotationQuery struct {
    *queries.Query
}

func BuildpackAnnotations

func BuildpackAnnotations(mods ...qm.QueryMod) buildpackAnnotationQuery

BuildpackAnnotations retrieves all the records using an executor.

func (buildpackAnnotationQuery) All

func (q buildpackAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (BuildpackAnnotationSlice, error)

All returns all BuildpackAnnotation records from the query.

func (buildpackAnnotationQuery) Count

func (q buildpackAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all BuildpackAnnotation records in the query.

func (buildpackAnnotationQuery) Delete

func (q buildpackAnnotationQuery) Delete(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single BuildpackAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (buildpackAnnotationQuery) DeleteAll

func (q buildpackAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (buildpackAnnotationQuery) DeleteAllSlice

func (q buildpackAnnotationQuery) DeleteAllSlice(o BuildpackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (buildpackAnnotationQuery) Exists

func (q buildpackAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (buildpackAnnotationQuery) Insert

func (q buildpackAnnotationQuery) Insert(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (buildpackAnnotationQuery) One

func (q buildpackAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*BuildpackAnnotation, error)

One returns a single buildpackAnnotation record from the query.

func (buildpackAnnotationQuery) Reload

func (q buildpackAnnotationQuery) Reload(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (buildpackAnnotationQuery) ReloadAll

func (q buildpackAnnotationQuery) ReloadAll(o *BuildpackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (buildpackAnnotationQuery) RemoveResource

func (q buildpackAnnotationQuery) RemoveResource(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Buildpack) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (buildpackAnnotationQuery) Resource

func (q buildpackAnnotationQuery) Resource(o *BuildpackAnnotation, mods ...qm.QueryMod) buildpackQuery

Resource pointed to by the foreign key.

func (buildpackAnnotationQuery) SetResource

func (q buildpackAnnotationQuery) SetResource(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Buildpack) error

SetResource of the buildpackAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceBuildpackAnnotations.

func (buildpackAnnotationQuery) Update

func (q buildpackAnnotationQuery) Update(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the BuildpackAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (buildpackAnnotationQuery) UpdateAll

func (q buildpackAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (buildpackAnnotationQuery) UpdateAllSlice

func (q buildpackAnnotationQuery) UpdateAllSlice(o BuildpackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (buildpackAnnotationQuery) Upsert

func (q buildpackAnnotationQuery) Upsert(o *BuildpackAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type buildpackAnnotationR

buildpackAnnotationR is where relationships are stored.

type buildpackAnnotationR struct {
    Resource *Buildpack `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*buildpackAnnotationR) NewStruct

func (*buildpackAnnotationR) NewStruct() *buildpackAnnotationR

NewStruct creates a new relationship struct

type buildpackL

buildpackL is where Load methods for each relationship are stored.

type buildpackL struct{}

func (buildpackL) LoadResourceBuildpackAnnotations

func (buildpackL) LoadResourceBuildpackAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuildpack interface{}, mods queries.Applicator) error

LoadResourceBuildpackAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (buildpackL) LoadResourceBuildpackLabels

func (buildpackL) LoadResourceBuildpackLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuildpack interface{}, mods queries.Applicator) error

LoadResourceBuildpackLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type buildpackLabelL

buildpackLabelL is where Load methods for each relationship are stored.

type buildpackLabelL struct{}

func (buildpackLabelL) LoadResource

func (buildpackLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuildpackLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type buildpackLabelQuery

type buildpackLabelQuery struct {
    *queries.Query
}

func BuildpackLabels

func BuildpackLabels(mods ...qm.QueryMod) buildpackLabelQuery

BuildpackLabels retrieves all the records using an executor.

func (buildpackLabelQuery) All

func (q buildpackLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (BuildpackLabelSlice, error)

All returns all BuildpackLabel records from the query.

func (buildpackLabelQuery) Count

func (q buildpackLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all BuildpackLabel records in the query.

func (buildpackLabelQuery) Delete

func (q buildpackLabelQuery) Delete(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single BuildpackLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (buildpackLabelQuery) DeleteAll

func (q buildpackLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (buildpackLabelQuery) DeleteAllSlice

func (q buildpackLabelQuery) DeleteAllSlice(o BuildpackLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (buildpackLabelQuery) Exists

func (q buildpackLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (buildpackLabelQuery) Insert

func (q buildpackLabelQuery) Insert(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (buildpackLabelQuery) One

func (q buildpackLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*BuildpackLabel, error)

One returns a single buildpackLabel record from the query.

func (buildpackLabelQuery) Reload

func (q buildpackLabelQuery) Reload(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (buildpackLabelQuery) ReloadAll

func (q buildpackLabelQuery) ReloadAll(o *BuildpackLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (buildpackLabelQuery) RemoveResource

func (q buildpackLabelQuery) RemoveResource(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor, related *Buildpack) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (buildpackLabelQuery) Resource

func (q buildpackLabelQuery) Resource(o *BuildpackLabel, mods ...qm.QueryMod) buildpackQuery

Resource pointed to by the foreign key.

func (buildpackLabelQuery) SetResource

func (q buildpackLabelQuery) SetResource(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Buildpack) error

SetResource of the buildpackLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceBuildpackLabels.

func (buildpackLabelQuery) Update

func (q buildpackLabelQuery) Update(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the BuildpackLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (buildpackLabelQuery) UpdateAll

func (q buildpackLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (buildpackLabelQuery) UpdateAllSlice

func (q buildpackLabelQuery) UpdateAllSlice(o BuildpackLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (buildpackLabelQuery) Upsert

func (q buildpackLabelQuery) Upsert(o *BuildpackLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type buildpackLabelR

buildpackLabelR is where relationships are stored.

type buildpackLabelR struct {
    Resource *Buildpack `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*buildpackLabelR) NewStruct

func (*buildpackLabelR) NewStruct() *buildpackLabelR

NewStruct creates a new relationship struct

type buildpackLifecycleBuildpackL

buildpackLifecycleBuildpackL is where Load methods for each relationship are stored.

type buildpackLifecycleBuildpackL struct{}

func (buildpackLifecycleBuildpackL) LoadBuildpackLifecycleDatum

func (buildpackLifecycleBuildpackL) LoadBuildpackLifecycleDatum(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuildpackLifecycleBuildpack interface{}, mods queries.Applicator) error

LoadBuildpackLifecycleDatum allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type buildpackLifecycleBuildpackQuery

type buildpackLifecycleBuildpackQuery struct {
    *queries.Query
}

func BuildpackLifecycleBuildpacks

func BuildpackLifecycleBuildpacks(mods ...qm.QueryMod) buildpackLifecycleBuildpackQuery

BuildpackLifecycleBuildpacks retrieves all the records using an executor.

func (buildpackLifecycleBuildpackQuery) All

func (q buildpackLifecycleBuildpackQuery) All(ctx context.Context, exec boil.ContextExecutor) (BuildpackLifecycleBuildpackSlice, error)

All returns all BuildpackLifecycleBuildpack records from the query.

func (buildpackLifecycleBuildpackQuery) BuildpackLifecycleDatum

func (q buildpackLifecycleBuildpackQuery) BuildpackLifecycleDatum(o *BuildpackLifecycleBuildpack, mods ...qm.QueryMod) buildpackLifecycleDatumQuery

BuildpackLifecycleDatum pointed to by the foreign key.

func (buildpackLifecycleBuildpackQuery) Count

func (q buildpackLifecycleBuildpackQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all BuildpackLifecycleBuildpack records in the query.

func (buildpackLifecycleBuildpackQuery) Delete

func (q buildpackLifecycleBuildpackQuery) Delete(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single BuildpackLifecycleBuildpack record with an executor. Delete will match against the primary key column to find the record to delete.

func (buildpackLifecycleBuildpackQuery) DeleteAll

func (q buildpackLifecycleBuildpackQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (buildpackLifecycleBuildpackQuery) DeleteAllSlice

func (q buildpackLifecycleBuildpackQuery) DeleteAllSlice(o BuildpackLifecycleBuildpackSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (buildpackLifecycleBuildpackQuery) Exists

func (q buildpackLifecycleBuildpackQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (buildpackLifecycleBuildpackQuery) Insert

func (q buildpackLifecycleBuildpackQuery) Insert(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (buildpackLifecycleBuildpackQuery) One

func (q buildpackLifecycleBuildpackQuery) One(ctx context.Context, exec boil.ContextExecutor) (*BuildpackLifecycleBuildpack, error)

One returns a single buildpackLifecycleBuildpack record from the query.

func (buildpackLifecycleBuildpackQuery) Reload

func (q buildpackLifecycleBuildpackQuery) Reload(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (buildpackLifecycleBuildpackQuery) ReloadAll

func (q buildpackLifecycleBuildpackQuery) ReloadAll(o *BuildpackLifecycleBuildpackSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (buildpackLifecycleBuildpackQuery) RemoveBuildpackLifecycleDatum

func (q buildpackLifecycleBuildpackQuery) RemoveBuildpackLifecycleDatum(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor, related *BuildpackLifecycleDatum) error

RemoveBuildpackLifecycleDatum relationship. Sets o.R.BuildpackLifecycleDatum to nil. Removes o from all passed in related items' relationships struct (Optional).

func (buildpackLifecycleBuildpackQuery) SetBuildpackLifecycleDatum

func (q buildpackLifecycleBuildpackQuery) SetBuildpackLifecycleDatum(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor, insert bool, related *BuildpackLifecycleDatum) error

SetBuildpackLifecycleDatum of the buildpackLifecycleBuildpack to the related item. Sets o.R.BuildpackLifecycleDatum to related. Adds o to related.R.BuildpackLifecycleBuildpacks.

func (buildpackLifecycleBuildpackQuery) Update

func (q buildpackLifecycleBuildpackQuery) Update(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the BuildpackLifecycleBuildpack. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (buildpackLifecycleBuildpackQuery) UpdateAll

func (q buildpackLifecycleBuildpackQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (buildpackLifecycleBuildpackQuery) UpdateAllSlice

func (q buildpackLifecycleBuildpackQuery) UpdateAllSlice(o BuildpackLifecycleBuildpackSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (buildpackLifecycleBuildpackQuery) Upsert

func (q buildpackLifecycleBuildpackQuery) Upsert(o *BuildpackLifecycleBuildpack, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type buildpackLifecycleBuildpackR

buildpackLifecycleBuildpackR is where relationships are stored.

type buildpackLifecycleBuildpackR struct {
    BuildpackLifecycleDatum *BuildpackLifecycleDatum `boil:"BuildpackLifecycleDatum" json:"BuildpackLifecycleDatum" toml:"BuildpackLifecycleDatum" yaml:"BuildpackLifecycleDatum"`
}

func (*buildpackLifecycleBuildpackR) NewStruct

func (*buildpackLifecycleBuildpackR) NewStruct() *buildpackLifecycleBuildpackR

NewStruct creates a new relationship struct

type buildpackLifecycleDatumL

buildpackLifecycleDatumL is where Load methods for each relationship are stored.

type buildpackLifecycleDatumL struct{}

func (buildpackLifecycleDatumL) LoadBuildpackLifecycleBuildpacks

func (buildpackLifecycleDatumL) LoadBuildpackLifecycleBuildpacks(ctx context.Context, e boil.ContextExecutor, singular bool, maybeBuildpackLifecycleDatum interface{}, mods queries.Applicator) error

LoadBuildpackLifecycleBuildpacks allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type buildpackLifecycleDatumQuery

type buildpackLifecycleDatumQuery struct {
    *queries.Query
}

func BuildpackLifecycleData

func BuildpackLifecycleData(mods ...qm.QueryMod) buildpackLifecycleDatumQuery

BuildpackLifecycleData retrieves all the records using an executor.

func (buildpackLifecycleDatumQuery) AddBuildpackLifecycleBuildpacks

func (q buildpackLifecycleDatumQuery) AddBuildpackLifecycleBuildpacks(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*BuildpackLifecycleBuildpack) error

AddBuildpackLifecycleBuildpacks adds the given related objects to the existing relationships of the buildpack_lifecycle_datum\, optionally inserting them as new records. Appends related to o.R.BuildpackLifecycleBuildpacks. Sets related.R.BuildpackLifecycleDatum appropriately.

func (buildpackLifecycleDatumQuery) All

func (q buildpackLifecycleDatumQuery) All(ctx context.Context, exec boil.ContextExecutor) (BuildpackLifecycleDatumSlice, error)

All returns all BuildpackLifecycleDatum records from the query.

func (buildpackLifecycleDatumQuery) BuildpackLifecycleBuildpacks

func (q buildpackLifecycleDatumQuery) BuildpackLifecycleBuildpacks(o *BuildpackLifecycleDatum, mods ...qm.QueryMod) buildpackLifecycleBuildpackQuery

BuildpackLifecycleBuildpacks retrieves all the buildpack_lifecycle_buildpack's BuildpackLifecycleBuildpacks with an executor.

func (buildpackLifecycleDatumQuery) Count

func (q buildpackLifecycleDatumQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all BuildpackLifecycleDatum records in the query.

func (buildpackLifecycleDatumQuery) Delete

func (q buildpackLifecycleDatumQuery) Delete(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single BuildpackLifecycleDatum record with an executor. Delete will match against the primary key column to find the record to delete.

func (buildpackLifecycleDatumQuery) DeleteAll

func (q buildpackLifecycleDatumQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (buildpackLifecycleDatumQuery) DeleteAllSlice

func (q buildpackLifecycleDatumQuery) DeleteAllSlice(o BuildpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (buildpackLifecycleDatumQuery) Exists

func (q buildpackLifecycleDatumQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (buildpackLifecycleDatumQuery) Insert

func (q buildpackLifecycleDatumQuery) Insert(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (buildpackLifecycleDatumQuery) One

func (q buildpackLifecycleDatumQuery) One(ctx context.Context, exec boil.ContextExecutor) (*BuildpackLifecycleDatum, error)

One returns a single buildpackLifecycleDatum record from the query.

func (buildpackLifecycleDatumQuery) Reload

func (q buildpackLifecycleDatumQuery) Reload(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (buildpackLifecycleDatumQuery) ReloadAll

func (q buildpackLifecycleDatumQuery) ReloadAll(o *BuildpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (buildpackLifecycleDatumQuery) RemoveBuildpackLifecycleBuildpacks

func (q buildpackLifecycleDatumQuery) RemoveBuildpackLifecycleBuildpacks(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, related ...*BuildpackLifecycleBuildpack) error

RemoveBuildpackLifecycleBuildpacks relationships from objects passed in. Removes related items from R.BuildpackLifecycleBuildpacks (uses pointer comparison\, removal does not keep order) Sets related.R.BuildpackLifecycleDatum.

func (buildpackLifecycleDatumQuery) SetBuildpackLifecycleBuildpacks

func (q buildpackLifecycleDatumQuery) SetBuildpackLifecycleBuildpacks(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*BuildpackLifecycleBuildpack) error

SetBuildpackLifecycleBuildpacks removes all previously related items of the buildpack_lifecycle_datum replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.BuildpackLifecycleDatum's BuildpackLifecycleBuildpacks accordingly. Replaces o.R.BuildpackLifecycleBuildpacks with related. Sets related.R.BuildpackLifecycleDatum's BuildpackLifecycleBuildpacks accordingly.

func (buildpackLifecycleDatumQuery) Update

func (q buildpackLifecycleDatumQuery) Update(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the BuildpackLifecycleDatum. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (buildpackLifecycleDatumQuery) UpdateAll

func (q buildpackLifecycleDatumQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (buildpackLifecycleDatumQuery) UpdateAllSlice

func (q buildpackLifecycleDatumQuery) UpdateAllSlice(o BuildpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (buildpackLifecycleDatumQuery) Upsert

func (q buildpackLifecycleDatumQuery) Upsert(o *BuildpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type buildpackLifecycleDatumR

buildpackLifecycleDatumR is where relationships are stored.

type buildpackLifecycleDatumR struct {
    BuildpackLifecycleBuildpacks BuildpackLifecycleBuildpackSlice `boil:"BuildpackLifecycleBuildpacks" json:"BuildpackLifecycleBuildpacks" toml:"BuildpackLifecycleBuildpacks" yaml:"BuildpackLifecycleBuildpacks"`
}

func (*buildpackLifecycleDatumR) NewStruct

func (*buildpackLifecycleDatumR) NewStruct() *buildpackLifecycleDatumR

NewStruct creates a new relationship struct

type buildpackQuery

type buildpackQuery struct {
    *queries.Query
}

func Buildpacks

func Buildpacks(mods ...qm.QueryMod) buildpackQuery

Buildpacks retrieves all the records using an executor.

func (buildpackQuery) AddResourceBuildpackAnnotations

func (q buildpackQuery) AddResourceBuildpackAnnotations(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*BuildpackAnnotation) error

AddResourceBuildpackAnnotations adds the given related objects to the existing relationships of the buildpack\, optionally inserting them as new records. Appends related to o.R.ResourceBuildpackAnnotations. Sets related.R.Resource appropriately.

func (buildpackQuery) AddResourceBuildpackLabels

func (q buildpackQuery) AddResourceBuildpackLabels(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*BuildpackLabel) error

AddResourceBuildpackLabels adds the given related objects to the existing relationships of the buildpack\, optionally inserting them as new records. Appends related to o.R.ResourceBuildpackLabels. Sets related.R.Resource appropriately.

func (buildpackQuery) All

func (q buildpackQuery) All(ctx context.Context, exec boil.ContextExecutor) (BuildpackSlice, error)

All returns all Buildpack records from the query.

func (buildpackQuery) Count

func (q buildpackQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Buildpack records in the query.

func (buildpackQuery) Delete

func (q buildpackQuery) Delete(o *Buildpack, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Buildpack record with an executor. Delete will match against the primary key column to find the record to delete.

func (buildpackQuery) DeleteAll

func (q buildpackQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (buildpackQuery) DeleteAllSlice

func (q buildpackQuery) DeleteAllSlice(o BuildpackSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (buildpackQuery) Exists

func (q buildpackQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (buildpackQuery) Insert

func (q buildpackQuery) Insert(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (buildpackQuery) One

func (q buildpackQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Buildpack, error)

One returns a single buildpack record from the query.

func (buildpackQuery) Reload

func (q buildpackQuery) Reload(o *Buildpack, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (buildpackQuery) ReloadAll

func (q buildpackQuery) ReloadAll(o *BuildpackSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (buildpackQuery) RemoveResourceBuildpackAnnotations

func (q buildpackQuery) RemoveResourceBuildpackAnnotations(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, related ...*BuildpackAnnotation) error

RemoveResourceBuildpackAnnotations relationships from objects passed in. Removes related items from R.ResourceBuildpackAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (buildpackQuery) RemoveResourceBuildpackLabels

func (q buildpackQuery) RemoveResourceBuildpackLabels(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, related ...*BuildpackLabel) error

RemoveResourceBuildpackLabels relationships from objects passed in. Removes related items from R.ResourceBuildpackLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (buildpackQuery) ResourceBuildpackAnnotations

func (q buildpackQuery) ResourceBuildpackAnnotations(o *Buildpack, mods ...qm.QueryMod) buildpackAnnotationQuery

ResourceBuildpackAnnotations retrieves all the buildpack_annotation's BuildpackAnnotations with an executor via resource_guid column.

func (buildpackQuery) ResourceBuildpackLabels

func (q buildpackQuery) ResourceBuildpackLabels(o *Buildpack, mods ...qm.QueryMod) buildpackLabelQuery

ResourceBuildpackLabels retrieves all the buildpack_label's BuildpackLabels with an executor via resource_guid column.

func (buildpackQuery) SetResourceBuildpackAnnotations

func (q buildpackQuery) SetResourceBuildpackAnnotations(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*BuildpackAnnotation) error

SetResourceBuildpackAnnotations removes all previously related items of the buildpack replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceBuildpackAnnotations accordingly. Replaces o.R.ResourceBuildpackAnnotations with related. Sets related.R.Resource's ResourceBuildpackAnnotations accordingly.

func (buildpackQuery) SetResourceBuildpackLabels

func (q buildpackQuery) SetResourceBuildpackLabels(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*BuildpackLabel) error

SetResourceBuildpackLabels removes all previously related items of the buildpack replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceBuildpackLabels accordingly. Replaces o.R.ResourceBuildpackLabels with related. Sets related.R.Resource's ResourceBuildpackLabels accordingly.

func (buildpackQuery) Update

func (q buildpackQuery) Update(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Buildpack. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (buildpackQuery) UpdateAll

func (q buildpackQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (buildpackQuery) UpdateAllSlice

func (q buildpackQuery) UpdateAllSlice(o BuildpackSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (buildpackQuery) Upsert

func (q buildpackQuery) Upsert(o *Buildpack, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type buildpackR

buildpackR is where relationships are stored.

type buildpackR struct {
    ResourceBuildpackAnnotations BuildpackAnnotationSlice `boil:"ResourceBuildpackAnnotations" json:"ResourceBuildpackAnnotations" toml:"ResourceBuildpackAnnotations" yaml:"ResourceBuildpackAnnotations"`
    ResourceBuildpackLabels      BuildpackLabelSlice      `boil:"ResourceBuildpackLabels" json:"ResourceBuildpackLabels" toml:"ResourceBuildpackLabels" yaml:"ResourceBuildpackLabels"`
}

func (*buildpackR) NewStruct

func (*buildpackR) NewStruct() *buildpackR

NewStruct creates a new relationship struct

type clockJobL

clockJobL is where Load methods for each relationship are stored.

type clockJobL struct{}

type clockJobQuery

type clockJobQuery struct {
    *queries.Query
}

func ClockJobs

func ClockJobs(mods ...qm.QueryMod) clockJobQuery

ClockJobs retrieves all the records using an executor.

func (clockJobQuery) All

func (q clockJobQuery) All(ctx context.Context, exec boil.ContextExecutor) (ClockJobSlice, error)

All returns all ClockJob records from the query.

func (clockJobQuery) Count

func (q clockJobQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ClockJob records in the query.

func (clockJobQuery) Delete

func (q clockJobQuery) Delete(o *ClockJob, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ClockJob record with an executor. Delete will match against the primary key column to find the record to delete.

func (clockJobQuery) DeleteAll

func (q clockJobQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (clockJobQuery) DeleteAllSlice

func (q clockJobQuery) DeleteAllSlice(o ClockJobSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (clockJobQuery) Exists

func (q clockJobQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (clockJobQuery) Insert

func (q clockJobQuery) Insert(o *ClockJob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (clockJobQuery) One

func (q clockJobQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ClockJob, error)

One returns a single clockJob record from the query.

func (clockJobQuery) Reload

func (q clockJobQuery) Reload(o *ClockJob, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (clockJobQuery) ReloadAll

func (q clockJobQuery) ReloadAll(o *ClockJobSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (clockJobQuery) Update

func (q clockJobQuery) Update(o *ClockJob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ClockJob. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (clockJobQuery) UpdateAll

func (q clockJobQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (clockJobQuery) UpdateAllSlice

func (q clockJobQuery) UpdateAllSlice(o ClockJobSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (clockJobQuery) Upsert

func (q clockJobQuery) Upsert(o *ClockJob, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type clockJobR

clockJobR is where relationships are stored.

type clockJobR struct {
}

func (*clockJobR) NewStruct

func (*clockJobR) NewStruct() *clockJobR

NewStruct creates a new relationship struct

type delayedJobL

delayedJobL is where Load methods for each relationship are stored.

type delayedJobL struct{}

type delayedJobQuery

type delayedJobQuery struct {
    *queries.Query
}

func DelayedJobs

func DelayedJobs(mods ...qm.QueryMod) delayedJobQuery

DelayedJobs retrieves all the records using an executor.

func (delayedJobQuery) All

func (q delayedJobQuery) All(ctx context.Context, exec boil.ContextExecutor) (DelayedJobSlice, error)

All returns all DelayedJob records from the query.

func (delayedJobQuery) Count

func (q delayedJobQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all DelayedJob records in the query.

func (delayedJobQuery) Delete

func (q delayedJobQuery) Delete(o *DelayedJob, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single DelayedJob record with an executor. Delete will match against the primary key column to find the record to delete.

func (delayedJobQuery) DeleteAll

func (q delayedJobQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (delayedJobQuery) DeleteAllSlice

func (q delayedJobQuery) DeleteAllSlice(o DelayedJobSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (delayedJobQuery) Exists

func (q delayedJobQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (delayedJobQuery) Insert

func (q delayedJobQuery) Insert(o *DelayedJob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (delayedJobQuery) One

func (q delayedJobQuery) One(ctx context.Context, exec boil.ContextExecutor) (*DelayedJob, error)

One returns a single delayedJob record from the query.

func (delayedJobQuery) Reload

func (q delayedJobQuery) Reload(o *DelayedJob, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (delayedJobQuery) ReloadAll

func (q delayedJobQuery) ReloadAll(o *DelayedJobSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (delayedJobQuery) Update

func (q delayedJobQuery) Update(o *DelayedJob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the DelayedJob. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (delayedJobQuery) UpdateAll

func (q delayedJobQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (delayedJobQuery) UpdateAllSlice

func (q delayedJobQuery) UpdateAllSlice(o DelayedJobSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (delayedJobQuery) Upsert

func (q delayedJobQuery) Upsert(o *DelayedJob, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type delayedJobR

delayedJobR is where relationships are stored.

type delayedJobR struct {
}

func (*delayedJobR) NewStruct

func (*delayedJobR) NewStruct() *delayedJobR

NewStruct creates a new relationship struct

type deploymentAnnotationL

deploymentAnnotationL is where Load methods for each relationship are stored.

type deploymentAnnotationL struct{}

func (deploymentAnnotationL) LoadResource

func (deploymentAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDeploymentAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type deploymentAnnotationQuery

type deploymentAnnotationQuery struct {
    *queries.Query
}

func DeploymentAnnotations

func DeploymentAnnotations(mods ...qm.QueryMod) deploymentAnnotationQuery

DeploymentAnnotations retrieves all the records using an executor.

func (deploymentAnnotationQuery) All

func (q deploymentAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (DeploymentAnnotationSlice, error)

All returns all DeploymentAnnotation records from the query.

func (deploymentAnnotationQuery) Count

func (q deploymentAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all DeploymentAnnotation records in the query.

func (deploymentAnnotationQuery) Delete

func (q deploymentAnnotationQuery) Delete(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single DeploymentAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (deploymentAnnotationQuery) DeleteAll

func (q deploymentAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (deploymentAnnotationQuery) DeleteAllSlice

func (q deploymentAnnotationQuery) DeleteAllSlice(o DeploymentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (deploymentAnnotationQuery) Exists

func (q deploymentAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (deploymentAnnotationQuery) Insert

func (q deploymentAnnotationQuery) Insert(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (deploymentAnnotationQuery) One

func (q deploymentAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*DeploymentAnnotation, error)

One returns a single deploymentAnnotation record from the query.

func (deploymentAnnotationQuery) Reload

func (q deploymentAnnotationQuery) Reload(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (deploymentAnnotationQuery) ReloadAll

func (q deploymentAnnotationQuery) ReloadAll(o *DeploymentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (deploymentAnnotationQuery) RemoveResource

func (q deploymentAnnotationQuery) RemoveResource(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Deployment) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (deploymentAnnotationQuery) Resource

func (q deploymentAnnotationQuery) Resource(o *DeploymentAnnotation, mods ...qm.QueryMod) deploymentQuery

Resource pointed to by the foreign key.

func (deploymentAnnotationQuery) SetResource

func (q deploymentAnnotationQuery) SetResource(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Deployment) error

SetResource of the deploymentAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceDeploymentAnnotations.

func (deploymentAnnotationQuery) Update

func (q deploymentAnnotationQuery) Update(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the DeploymentAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (deploymentAnnotationQuery) UpdateAll

func (q deploymentAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (deploymentAnnotationQuery) UpdateAllSlice

func (q deploymentAnnotationQuery) UpdateAllSlice(o DeploymentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (deploymentAnnotationQuery) Upsert

func (q deploymentAnnotationQuery) Upsert(o *DeploymentAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type deploymentAnnotationR

deploymentAnnotationR is where relationships are stored.

type deploymentAnnotationR struct {
    Resource *Deployment `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*deploymentAnnotationR) NewStruct

func (*deploymentAnnotationR) NewStruct() *deploymentAnnotationR

NewStruct creates a new relationship struct

type deploymentL

deploymentL is where Load methods for each relationship are stored.

type deploymentL struct{}

func (deploymentL) LoadApp

func (deploymentL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDeployment interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (deploymentL) LoadDeploymentProcesses

func (deploymentL) LoadDeploymentProcesses(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDeployment interface{}, mods queries.Applicator) error

LoadDeploymentProcesses allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (deploymentL) LoadResourceDeploymentAnnotations

func (deploymentL) LoadResourceDeploymentAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDeployment interface{}, mods queries.Applicator) error

LoadResourceDeploymentAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (deploymentL) LoadResourceDeploymentLabels

func (deploymentL) LoadResourceDeploymentLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDeployment interface{}, mods queries.Applicator) error

LoadResourceDeploymentLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type deploymentLabelL

deploymentLabelL is where Load methods for each relationship are stored.

type deploymentLabelL struct{}

func (deploymentLabelL) LoadResource

func (deploymentLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDeploymentLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type deploymentLabelQuery

type deploymentLabelQuery struct {
    *queries.Query
}

func DeploymentLabels

func DeploymentLabels(mods ...qm.QueryMod) deploymentLabelQuery

DeploymentLabels retrieves all the records using an executor.

func (deploymentLabelQuery) All

func (q deploymentLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (DeploymentLabelSlice, error)

All returns all DeploymentLabel records from the query.

func (deploymentLabelQuery) Count

func (q deploymentLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all DeploymentLabel records in the query.

func (deploymentLabelQuery) Delete

func (q deploymentLabelQuery) Delete(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single DeploymentLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (deploymentLabelQuery) DeleteAll

func (q deploymentLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (deploymentLabelQuery) DeleteAllSlice

func (q deploymentLabelQuery) DeleteAllSlice(o DeploymentLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (deploymentLabelQuery) Exists

func (q deploymentLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (deploymentLabelQuery) Insert

func (q deploymentLabelQuery) Insert(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (deploymentLabelQuery) One

func (q deploymentLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*DeploymentLabel, error)

One returns a single deploymentLabel record from the query.

func (deploymentLabelQuery) Reload

func (q deploymentLabelQuery) Reload(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (deploymentLabelQuery) ReloadAll

func (q deploymentLabelQuery) ReloadAll(o *DeploymentLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (deploymentLabelQuery) RemoveResource

func (q deploymentLabelQuery) RemoveResource(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor, related *Deployment) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (deploymentLabelQuery) Resource

func (q deploymentLabelQuery) Resource(o *DeploymentLabel, mods ...qm.QueryMod) deploymentQuery

Resource pointed to by the foreign key.

func (deploymentLabelQuery) SetResource

func (q deploymentLabelQuery) SetResource(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Deployment) error

SetResource of the deploymentLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceDeploymentLabels.

func (deploymentLabelQuery) Update

func (q deploymentLabelQuery) Update(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the DeploymentLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (deploymentLabelQuery) UpdateAll

func (q deploymentLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (deploymentLabelQuery) UpdateAllSlice

func (q deploymentLabelQuery) UpdateAllSlice(o DeploymentLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (deploymentLabelQuery) Upsert

func (q deploymentLabelQuery) Upsert(o *DeploymentLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type deploymentLabelR

deploymentLabelR is where relationships are stored.

type deploymentLabelR struct {
    Resource *Deployment `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*deploymentLabelR) NewStruct

func (*deploymentLabelR) NewStruct() *deploymentLabelR

NewStruct creates a new relationship struct

type deploymentProcessL

deploymentProcessL is where Load methods for each relationship are stored.

type deploymentProcessL struct{}

func (deploymentProcessL) LoadDeployment

func (deploymentProcessL) LoadDeployment(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDeploymentProcess interface{}, mods queries.Applicator) error

LoadDeployment allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type deploymentProcessQuery

type deploymentProcessQuery struct {
    *queries.Query
}

func DeploymentProcesses

func DeploymentProcesses(mods ...qm.QueryMod) deploymentProcessQuery

DeploymentProcesses retrieves all the records using an executor.

func (deploymentProcessQuery) All

func (q deploymentProcessQuery) All(ctx context.Context, exec boil.ContextExecutor) (DeploymentProcessSlice, error)

All returns all DeploymentProcess records from the query.

func (deploymentProcessQuery) Count

func (q deploymentProcessQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all DeploymentProcess records in the query.

func (deploymentProcessQuery) Delete

func (q deploymentProcessQuery) Delete(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single DeploymentProcess record with an executor. Delete will match against the primary key column to find the record to delete.

func (deploymentProcessQuery) DeleteAll

func (q deploymentProcessQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (deploymentProcessQuery) DeleteAllSlice

func (q deploymentProcessQuery) DeleteAllSlice(o DeploymentProcessSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (deploymentProcessQuery) Deployment

func (q deploymentProcessQuery) Deployment(o *DeploymentProcess, mods ...qm.QueryMod) deploymentQuery

Deployment pointed to by the foreign key.

func (deploymentProcessQuery) Exists

func (q deploymentProcessQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (deploymentProcessQuery) Insert

func (q deploymentProcessQuery) Insert(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (deploymentProcessQuery) One

func (q deploymentProcessQuery) One(ctx context.Context, exec boil.ContextExecutor) (*DeploymentProcess, error)

One returns a single deploymentProcess record from the query.

func (deploymentProcessQuery) Reload

func (q deploymentProcessQuery) Reload(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (deploymentProcessQuery) ReloadAll

func (q deploymentProcessQuery) ReloadAll(o *DeploymentProcessSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (deploymentProcessQuery) RemoveDeployment

func (q deploymentProcessQuery) RemoveDeployment(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor, related *Deployment) error

RemoveDeployment relationship. Sets o.R.Deployment to nil. Removes o from all passed in related items' relationships struct (Optional).

func (deploymentProcessQuery) SetDeployment

func (q deploymentProcessQuery) SetDeployment(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Deployment) error

SetDeployment of the deploymentProcess to the related item. Sets o.R.Deployment to related. Adds o to related.R.DeploymentProcesses.

func (deploymentProcessQuery) Update

func (q deploymentProcessQuery) Update(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the DeploymentProcess. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (deploymentProcessQuery) UpdateAll

func (q deploymentProcessQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (deploymentProcessQuery) UpdateAllSlice

func (q deploymentProcessQuery) UpdateAllSlice(o DeploymentProcessSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (deploymentProcessQuery) Upsert

func (q deploymentProcessQuery) Upsert(o *DeploymentProcess, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type deploymentProcessR

deploymentProcessR is where relationships are stored.

type deploymentProcessR struct {
    Deployment *Deployment `boil:"Deployment" json:"Deployment" toml:"Deployment" yaml:"Deployment"`
}

func (*deploymentProcessR) NewStruct

func (*deploymentProcessR) NewStruct() *deploymentProcessR

NewStruct creates a new relationship struct

type deploymentQuery

type deploymentQuery struct {
    *queries.Query
}

func Deployments

func Deployments(mods ...qm.QueryMod) deploymentQuery

Deployments retrieves all the records using an executor.

func (deploymentQuery) AddDeploymentProcesses

func (q deploymentQuery) AddDeploymentProcesses(o *Deployment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DeploymentProcess) error

AddDeploymentProcesses adds the given related objects to the existing relationships of the deployment\, optionally inserting them as new records. Appends related to o.R.DeploymentProcesses. Sets related.R.Deployment appropriately.

func (deploymentQuery) AddResourceDeploymentAnnotations

func (q deploymentQuery) AddResourceDeploymentAnnotations(o *Deployment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DeploymentAnnotation) error

AddResourceDeploymentAnnotations adds the given related objects to the existing relationships of the deployment\, optionally inserting them as new records. Appends related to o.R.ResourceDeploymentAnnotations. Sets related.R.Resource appropriately.

func (deploymentQuery) AddResourceDeploymentLabels

func (q deploymentQuery) AddResourceDeploymentLabels(o *Deployment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DeploymentLabel) error

AddResourceDeploymentLabels adds the given related objects to the existing relationships of the deployment\, optionally inserting them as new records. Appends related to o.R.ResourceDeploymentLabels. Sets related.R.Resource appropriately.

func (deploymentQuery) All

func (q deploymentQuery) All(ctx context.Context, exec boil.ContextExecutor) (DeploymentSlice, error)

All returns all Deployment records from the query.

func (deploymentQuery) App

func (q deploymentQuery) App(o *Deployment, mods ...qm.QueryMod) appQuery

App pointed to by the foreign key.

func (deploymentQuery) Count

func (q deploymentQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Deployment records in the query.

func (deploymentQuery) Delete

func (q deploymentQuery) Delete(o *Deployment, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Deployment record with an executor. Delete will match against the primary key column to find the record to delete.

func (deploymentQuery) DeleteAll

func (q deploymentQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (deploymentQuery) DeleteAllSlice

func (q deploymentQuery) DeleteAllSlice(o DeploymentSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (deploymentQuery) DeploymentProcesses

func (q deploymentQuery) DeploymentProcesses(o *Deployment, mods ...qm.QueryMod) deploymentProcessQuery

DeploymentProcesses retrieves all the deployment_process's DeploymentProcesses with an executor.

func (deploymentQuery) Exists

func (q deploymentQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (deploymentQuery) Insert

func (q deploymentQuery) Insert(o *Deployment, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (deploymentQuery) One

func (q deploymentQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Deployment, error)

One returns a single deployment record from the query.

func (deploymentQuery) Reload

func (q deploymentQuery) Reload(o *Deployment, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (deploymentQuery) ReloadAll

func (q deploymentQuery) ReloadAll(o *DeploymentSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (deploymentQuery) RemoveApp

func (q deploymentQuery) RemoveApp(o *Deployment, ctx context.Context, exec boil.ContextExecutor, related *App) error

RemoveApp relationship. Sets o.R.App to nil. Removes o from all passed in related items' relationships struct (Optional).

func (deploymentQuery) RemoveDeploymentProcesses

func (q deploymentQuery) RemoveDeploymentProcesses(o *Deployment, ctx context.Context, exec boil.ContextExecutor, related ...*DeploymentProcess) error

RemoveDeploymentProcesses relationships from objects passed in. Removes related items from R.DeploymentProcesses (uses pointer comparison\, removal does not keep order) Sets related.R.Deployment.

func (deploymentQuery) RemoveResourceDeploymentAnnotations

func (q deploymentQuery) RemoveResourceDeploymentAnnotations(o *Deployment, ctx context.Context, exec boil.ContextExecutor, related ...*DeploymentAnnotation) error

RemoveResourceDeploymentAnnotations relationships from objects passed in. Removes related items from R.ResourceDeploymentAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (deploymentQuery) RemoveResourceDeploymentLabels

func (q deploymentQuery) RemoveResourceDeploymentLabels(o *Deployment, ctx context.Context, exec boil.ContextExecutor, related ...*DeploymentLabel) error

RemoveResourceDeploymentLabels relationships from objects passed in. Removes related items from R.ResourceDeploymentLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (deploymentQuery) ResourceDeploymentAnnotations

func (q deploymentQuery) ResourceDeploymentAnnotations(o *Deployment, mods ...qm.QueryMod) deploymentAnnotationQuery

ResourceDeploymentAnnotations retrieves all the deployment_annotation's DeploymentAnnotations with an executor via resource_guid column.

func (deploymentQuery) ResourceDeploymentLabels

func (q deploymentQuery) ResourceDeploymentLabels(o *Deployment, mods ...qm.QueryMod) deploymentLabelQuery

ResourceDeploymentLabels retrieves all the deployment_label's DeploymentLabels with an executor via resource_guid column.

func (deploymentQuery) SetApp

func (q deploymentQuery) SetApp(o *Deployment, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetApp of the deployment to the related item. Sets o.R.App to related. Adds o to related.R.Deployments.

func (deploymentQuery) SetDeploymentProcesses

func (q deploymentQuery) SetDeploymentProcesses(o *Deployment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DeploymentProcess) error

SetDeploymentProcesses removes all previously related items of the deployment replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Deployment's DeploymentProcesses accordingly. Replaces o.R.DeploymentProcesses with related. Sets related.R.Deployment's DeploymentProcesses accordingly.

func (deploymentQuery) SetResourceDeploymentAnnotations

func (q deploymentQuery) SetResourceDeploymentAnnotations(o *Deployment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DeploymentAnnotation) error

SetResourceDeploymentAnnotations removes all previously related items of the deployment replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceDeploymentAnnotations accordingly. Replaces o.R.ResourceDeploymentAnnotations with related. Sets related.R.Resource's ResourceDeploymentAnnotations accordingly.

func (deploymentQuery) SetResourceDeploymentLabels

func (q deploymentQuery) SetResourceDeploymentLabels(o *Deployment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DeploymentLabel) error

SetResourceDeploymentLabels removes all previously related items of the deployment replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceDeploymentLabels accordingly. Replaces o.R.ResourceDeploymentLabels with related. Sets related.R.Resource's ResourceDeploymentLabels accordingly.

func (deploymentQuery) Update

func (q deploymentQuery) Update(o *Deployment, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Deployment. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (deploymentQuery) UpdateAll

func (q deploymentQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (deploymentQuery) UpdateAllSlice

func (q deploymentQuery) UpdateAllSlice(o DeploymentSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (deploymentQuery) Upsert

func (q deploymentQuery) Upsert(o *Deployment, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type deploymentR

deploymentR is where relationships are stored.

type deploymentR struct {
    App                           *App                      `boil:"App" json:"App" toml:"App" yaml:"App"`
    ResourceDeploymentAnnotations DeploymentAnnotationSlice `boil:"ResourceDeploymentAnnotations" json:"ResourceDeploymentAnnotations" toml:"ResourceDeploymentAnnotations" yaml:"ResourceDeploymentAnnotations"`
    ResourceDeploymentLabels      DeploymentLabelSlice      `boil:"ResourceDeploymentLabels" json:"ResourceDeploymentLabels" toml:"ResourceDeploymentLabels" yaml:"ResourceDeploymentLabels"`
    DeploymentProcesses           DeploymentProcessSlice    `boil:"DeploymentProcesses" json:"DeploymentProcesses" toml:"DeploymentProcesses" yaml:"DeploymentProcesses"`
}

func (*deploymentR) NewStruct

func (*deploymentR) NewStruct() *deploymentR

NewStruct creates a new relationship struct

type domainAnnotationL

domainAnnotationL is where Load methods for each relationship are stored.

type domainAnnotationL struct{}

func (domainAnnotationL) LoadResource

func (domainAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDomainAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type domainAnnotationQuery

type domainAnnotationQuery struct {
    *queries.Query
}

func DomainAnnotations

func DomainAnnotations(mods ...qm.QueryMod) domainAnnotationQuery

DomainAnnotations retrieves all the records using an executor.

func (domainAnnotationQuery) All

func (q domainAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (DomainAnnotationSlice, error)

All returns all DomainAnnotation records from the query.

func (domainAnnotationQuery) Count

func (q domainAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all DomainAnnotation records in the query.

func (domainAnnotationQuery) Delete

func (q domainAnnotationQuery) Delete(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single DomainAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (domainAnnotationQuery) DeleteAll

func (q domainAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (domainAnnotationQuery) DeleteAllSlice

func (q domainAnnotationQuery) DeleteAllSlice(o DomainAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (domainAnnotationQuery) Exists

func (q domainAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (domainAnnotationQuery) Insert

func (q domainAnnotationQuery) Insert(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (domainAnnotationQuery) One

func (q domainAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*DomainAnnotation, error)

One returns a single domainAnnotation record from the query.

func (domainAnnotationQuery) Reload

func (q domainAnnotationQuery) Reload(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (domainAnnotationQuery) ReloadAll

func (q domainAnnotationQuery) ReloadAll(o *DomainAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (domainAnnotationQuery) RemoveResource

func (q domainAnnotationQuery) RemoveResource(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Domain) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (domainAnnotationQuery) Resource

func (q domainAnnotationQuery) Resource(o *DomainAnnotation, mods ...qm.QueryMod) domainQuery

Resource pointed to by the foreign key.

func (domainAnnotationQuery) SetResource

func (q domainAnnotationQuery) SetResource(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Domain) error

SetResource of the domainAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceDomainAnnotations.

func (domainAnnotationQuery) Update

func (q domainAnnotationQuery) Update(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the DomainAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (domainAnnotationQuery) UpdateAll

func (q domainAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (domainAnnotationQuery) UpdateAllSlice

func (q domainAnnotationQuery) UpdateAllSlice(o DomainAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (domainAnnotationQuery) Upsert

func (q domainAnnotationQuery) Upsert(o *DomainAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type domainAnnotationR

domainAnnotationR is where relationships are stored.

type domainAnnotationR struct {
    Resource *Domain `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*domainAnnotationR) NewStruct

func (*domainAnnotationR) NewStruct() *domainAnnotationR

NewStruct creates a new relationship struct

type domainL

domainL is where Load methods for each relationship are stored.

type domainL struct{}

func (domainL) LoadOwningOrganization

func (domainL) LoadOwningOrganization(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDomain interface{}, mods queries.Applicator) error

LoadOwningOrganization allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (domainL) LoadPrivateDomainOrganizationsPrivateDomains

func (domainL) LoadPrivateDomainOrganizationsPrivateDomains(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDomain interface{}, mods queries.Applicator) error

LoadPrivateDomainOrganizationsPrivateDomains allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (domainL) LoadResourceDomainAnnotations

func (domainL) LoadResourceDomainAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDomain interface{}, mods queries.Applicator) error

LoadResourceDomainAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (domainL) LoadResourceDomainLabels

func (domainL) LoadResourceDomainLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDomain interface{}, mods queries.Applicator) error

LoadResourceDomainLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (domainL) LoadRoutes

func (domainL) LoadRoutes(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDomain interface{}, mods queries.Applicator) error

LoadRoutes allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type domainLabelL

domainLabelL is where Load methods for each relationship are stored.

type domainLabelL struct{}

func (domainLabelL) LoadResource

func (domainLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDomainLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type domainLabelQuery

type domainLabelQuery struct {
    *queries.Query
}

func DomainLabels

func DomainLabels(mods ...qm.QueryMod) domainLabelQuery

DomainLabels retrieves all the records using an executor.

func (domainLabelQuery) All

func (q domainLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (DomainLabelSlice, error)

All returns all DomainLabel records from the query.

func (domainLabelQuery) Count

func (q domainLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all DomainLabel records in the query.

func (domainLabelQuery) Delete

func (q domainLabelQuery) Delete(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single DomainLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (domainLabelQuery) DeleteAll

func (q domainLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (domainLabelQuery) DeleteAllSlice

func (q domainLabelQuery) DeleteAllSlice(o DomainLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (domainLabelQuery) Exists

func (q domainLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (domainLabelQuery) Insert

func (q domainLabelQuery) Insert(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (domainLabelQuery) One

func (q domainLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*DomainLabel, error)

One returns a single domainLabel record from the query.

func (domainLabelQuery) Reload

func (q domainLabelQuery) Reload(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (domainLabelQuery) ReloadAll

func (q domainLabelQuery) ReloadAll(o *DomainLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (domainLabelQuery) RemoveResource

func (q domainLabelQuery) RemoveResource(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor, related *Domain) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (domainLabelQuery) Resource

func (q domainLabelQuery) Resource(o *DomainLabel, mods ...qm.QueryMod) domainQuery

Resource pointed to by the foreign key.

func (domainLabelQuery) SetResource

func (q domainLabelQuery) SetResource(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Domain) error

SetResource of the domainLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceDomainLabels.

func (domainLabelQuery) Update

func (q domainLabelQuery) Update(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the DomainLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (domainLabelQuery) UpdateAll

func (q domainLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (domainLabelQuery) UpdateAllSlice

func (q domainLabelQuery) UpdateAllSlice(o DomainLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (domainLabelQuery) Upsert

func (q domainLabelQuery) Upsert(o *DomainLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type domainLabelR

domainLabelR is where relationships are stored.

type domainLabelR struct {
    Resource *Domain `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*domainLabelR) NewStruct

func (*domainLabelR) NewStruct() *domainLabelR

NewStruct creates a new relationship struct

type domainQuery

type domainQuery struct {
    *queries.Query
}

func Domains

func Domains(mods ...qm.QueryMod) domainQuery

Domains retrieves all the records using an executor.

func (domainQuery) AddPrivateDomainOrganizationsPrivateDomains

func (q domainQuery) AddPrivateDomainOrganizationsPrivateDomains(o *Domain, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationsPrivateDomain) error

AddPrivateDomainOrganizationsPrivateDomains adds the given related objects to the existing relationships of the domain\, optionally inserting them as new records. Appends related to o.R.PrivateDomainOrganizationsPrivateDomains. Sets related.R.PrivateDomain appropriately.

func (domainQuery) AddResourceDomainAnnotations

func (q domainQuery) AddResourceDomainAnnotations(o *Domain, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DomainAnnotation) error

AddResourceDomainAnnotations adds the given related objects to the existing relationships of the domain\, optionally inserting them as new records. Appends related to o.R.ResourceDomainAnnotations. Sets related.R.Resource appropriately.

func (domainQuery) AddResourceDomainLabels

func (q domainQuery) AddResourceDomainLabels(o *Domain, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DomainLabel) error

AddResourceDomainLabels adds the given related objects to the existing relationships of the domain\, optionally inserting them as new records. Appends related to o.R.ResourceDomainLabels. Sets related.R.Resource appropriately.

func (domainQuery) AddRoutes

func (q domainQuery) AddRoutes(o *Domain, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Route) error

AddRoutes adds the given related objects to the existing relationships of the domain\, optionally inserting them as new records. Appends related to o.R.Routes. Sets related.R.Domain appropriately.

func (domainQuery) All

func (q domainQuery) All(ctx context.Context, exec boil.ContextExecutor) (DomainSlice, error)

All returns all Domain records from the query.

func (domainQuery) Count

func (q domainQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Domain records in the query.

func (domainQuery) Delete

func (q domainQuery) Delete(o *Domain, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Domain record with an executor. Delete will match against the primary key column to find the record to delete.

func (domainQuery) DeleteAll

func (q domainQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (domainQuery) DeleteAllSlice

func (q domainQuery) DeleteAllSlice(o DomainSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (domainQuery) Exists

func (q domainQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (domainQuery) Insert

func (q domainQuery) Insert(o *Domain, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (domainQuery) One

func (q domainQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Domain, error)

One returns a single domain record from the query.

func (domainQuery) OwningOrganization

func (q domainQuery) OwningOrganization(o *Domain, mods ...qm.QueryMod) organizationQuery

OwningOrganization pointed to by the foreign key.

func (domainQuery) PrivateDomainOrganizationsPrivateDomains

func (q domainQuery) PrivateDomainOrganizationsPrivateDomains(o *Domain, mods ...qm.QueryMod) organizationsPrivateDomainQuery

PrivateDomainOrganizationsPrivateDomains retrieves all the organizations_private_domain's OrganizationsPrivateDomains with an executor via private_domain_id column.

func (domainQuery) Reload

func (q domainQuery) Reload(o *Domain, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (domainQuery) ReloadAll

func (q domainQuery) ReloadAll(o *DomainSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (domainQuery) RemoveOwningOrganization

func (q domainQuery) RemoveOwningOrganization(o *Domain, ctx context.Context, exec boil.ContextExecutor, related *Organization) error

RemoveOwningOrganization relationship. Sets o.R.OwningOrganization to nil. Removes o from all passed in related items' relationships struct (Optional).

func (domainQuery) RemoveResourceDomainAnnotations

func (q domainQuery) RemoveResourceDomainAnnotations(o *Domain, ctx context.Context, exec boil.ContextExecutor, related ...*DomainAnnotation) error

RemoveResourceDomainAnnotations relationships from objects passed in. Removes related items from R.ResourceDomainAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (domainQuery) RemoveResourceDomainLabels

func (q domainQuery) RemoveResourceDomainLabels(o *Domain, ctx context.Context, exec boil.ContextExecutor, related ...*DomainLabel) error

RemoveResourceDomainLabels relationships from objects passed in. Removes related items from R.ResourceDomainLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (domainQuery) ResourceDomainAnnotations

func (q domainQuery) ResourceDomainAnnotations(o *Domain, mods ...qm.QueryMod) domainAnnotationQuery

ResourceDomainAnnotations retrieves all the domain_annotation's DomainAnnotations with an executor via resource_guid column.

func (domainQuery) ResourceDomainLabels

func (q domainQuery) ResourceDomainLabels(o *Domain, mods ...qm.QueryMod) domainLabelQuery

ResourceDomainLabels retrieves all the domain_label's DomainLabels with an executor via resource_guid column.

func (domainQuery) Routes

func (q domainQuery) Routes(o *Domain, mods ...qm.QueryMod) routeQuery

Routes retrieves all the route's Routes with an executor.

func (domainQuery) SetOwningOrganization

func (q domainQuery) SetOwningOrganization(o *Domain, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Organization) error

SetOwningOrganization of the domain to the related item. Sets o.R.OwningOrganization to related. Adds o to related.R.OwningOrganizationDomains.

func (domainQuery) SetResourceDomainAnnotations

func (q domainQuery) SetResourceDomainAnnotations(o *Domain, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DomainAnnotation) error

SetResourceDomainAnnotations removes all previously related items of the domain replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceDomainAnnotations accordingly. Replaces o.R.ResourceDomainAnnotations with related. Sets related.R.Resource's ResourceDomainAnnotations accordingly.

func (domainQuery) SetResourceDomainLabels

func (q domainQuery) SetResourceDomainLabels(o *Domain, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DomainLabel) error

SetResourceDomainLabels removes all previously related items of the domain replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceDomainLabels accordingly. Replaces o.R.ResourceDomainLabels with related. Sets related.R.Resource's ResourceDomainLabels accordingly.

func (domainQuery) Update

func (q domainQuery) Update(o *Domain, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Domain. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (domainQuery) UpdateAll

func (q domainQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (domainQuery) UpdateAllSlice

func (q domainQuery) UpdateAllSlice(o DomainSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (domainQuery) Upsert

func (q domainQuery) Upsert(o *Domain, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type domainR

domainR is where relationships are stored.

type domainR struct {
    OwningOrganization                       *Organization                   `boil:"OwningOrganization" json:"OwningOrganization" toml:"OwningOrganization" yaml:"OwningOrganization"`
    ResourceDomainAnnotations                DomainAnnotationSlice           `boil:"ResourceDomainAnnotations" json:"ResourceDomainAnnotations" toml:"ResourceDomainAnnotations" yaml:"ResourceDomainAnnotations"`
    ResourceDomainLabels                     DomainLabelSlice                `boil:"ResourceDomainLabels" json:"ResourceDomainLabels" toml:"ResourceDomainLabels" yaml:"ResourceDomainLabels"`
    PrivateDomainOrganizationsPrivateDomains OrganizationsPrivateDomainSlice `boil:"PrivateDomainOrganizationsPrivateDomains" json:"PrivateDomainOrganizationsPrivateDomains" toml:"PrivateDomainOrganizationsPrivateDomains" yaml:"PrivateDomainOrganizationsPrivateDomains"`
    Routes                                   RouteSlice                      `boil:"Routes" json:"Routes" toml:"Routes" yaml:"Routes"`
}

func (*domainR) NewStruct

func (*domainR) NewStruct() *domainR

NewStruct creates a new relationship struct

type dropletAnnotationL

dropletAnnotationL is where Load methods for each relationship are stored.

type dropletAnnotationL struct{}

func (dropletAnnotationL) LoadResource

func (dropletAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDropletAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type dropletAnnotationQuery

type dropletAnnotationQuery struct {
    *queries.Query
}

func DropletAnnotations

func DropletAnnotations(mods ...qm.QueryMod) dropletAnnotationQuery

DropletAnnotations retrieves all the records using an executor.

func (dropletAnnotationQuery) All

func (q dropletAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (DropletAnnotationSlice, error)

All returns all DropletAnnotation records from the query.

func (dropletAnnotationQuery) Count

func (q dropletAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all DropletAnnotation records in the query.

func (dropletAnnotationQuery) Delete

func (q dropletAnnotationQuery) Delete(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single DropletAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (dropletAnnotationQuery) DeleteAll

func (q dropletAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (dropletAnnotationQuery) DeleteAllSlice

func (q dropletAnnotationQuery) DeleteAllSlice(o DropletAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (dropletAnnotationQuery) Exists

func (q dropletAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (dropletAnnotationQuery) Insert

func (q dropletAnnotationQuery) Insert(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (dropletAnnotationQuery) One

func (q dropletAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*DropletAnnotation, error)

One returns a single dropletAnnotation record from the query.

func (dropletAnnotationQuery) Reload

func (q dropletAnnotationQuery) Reload(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (dropletAnnotationQuery) ReloadAll

func (q dropletAnnotationQuery) ReloadAll(o *DropletAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (dropletAnnotationQuery) RemoveResource

func (q dropletAnnotationQuery) RemoveResource(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Droplet) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (dropletAnnotationQuery) Resource

func (q dropletAnnotationQuery) Resource(o *DropletAnnotation, mods ...qm.QueryMod) dropletQuery

Resource pointed to by the foreign key.

func (dropletAnnotationQuery) SetResource

func (q dropletAnnotationQuery) SetResource(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Droplet) error

SetResource of the dropletAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceDropletAnnotations.

func (dropletAnnotationQuery) Update

func (q dropletAnnotationQuery) Update(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the DropletAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (dropletAnnotationQuery) UpdateAll

func (q dropletAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (dropletAnnotationQuery) UpdateAllSlice

func (q dropletAnnotationQuery) UpdateAllSlice(o DropletAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (dropletAnnotationQuery) Upsert

func (q dropletAnnotationQuery) Upsert(o *DropletAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type dropletAnnotationR

dropletAnnotationR is where relationships are stored.

type dropletAnnotationR struct {
    Resource *Droplet `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*dropletAnnotationR) NewStruct

func (*dropletAnnotationR) NewStruct() *dropletAnnotationR

NewStruct creates a new relationship struct

type dropletL

dropletL is where Load methods for each relationship are stored.

type dropletL struct{}

func (dropletL) LoadApp

func (dropletL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDroplet interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (dropletL) LoadResourceDropletAnnotations

func (dropletL) LoadResourceDropletAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDroplet interface{}, mods queries.Applicator) error

LoadResourceDropletAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (dropletL) LoadResourceDropletLabels

func (dropletL) LoadResourceDropletLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDroplet interface{}, mods queries.Applicator) error

LoadResourceDropletLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type dropletLabelL

dropletLabelL is where Load methods for each relationship are stored.

type dropletLabelL struct{}

func (dropletLabelL) LoadResource

func (dropletLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeDropletLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type dropletLabelQuery

type dropletLabelQuery struct {
    *queries.Query
}

func DropletLabels

func DropletLabels(mods ...qm.QueryMod) dropletLabelQuery

DropletLabels retrieves all the records using an executor.

func (dropletLabelQuery) All

func (q dropletLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (DropletLabelSlice, error)

All returns all DropletLabel records from the query.

func (dropletLabelQuery) Count

func (q dropletLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all DropletLabel records in the query.

func (dropletLabelQuery) Delete

func (q dropletLabelQuery) Delete(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single DropletLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (dropletLabelQuery) DeleteAll

func (q dropletLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (dropletLabelQuery) DeleteAllSlice

func (q dropletLabelQuery) DeleteAllSlice(o DropletLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (dropletLabelQuery) Exists

func (q dropletLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (dropletLabelQuery) Insert

func (q dropletLabelQuery) Insert(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (dropletLabelQuery) One

func (q dropletLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*DropletLabel, error)

One returns a single dropletLabel record from the query.

func (dropletLabelQuery) Reload

func (q dropletLabelQuery) Reload(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (dropletLabelQuery) ReloadAll

func (q dropletLabelQuery) ReloadAll(o *DropletLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (dropletLabelQuery) RemoveResource

func (q dropletLabelQuery) RemoveResource(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor, related *Droplet) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (dropletLabelQuery) Resource

func (q dropletLabelQuery) Resource(o *DropletLabel, mods ...qm.QueryMod) dropletQuery

Resource pointed to by the foreign key.

func (dropletLabelQuery) SetResource

func (q dropletLabelQuery) SetResource(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Droplet) error

SetResource of the dropletLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceDropletLabels.

func (dropletLabelQuery) Update

func (q dropletLabelQuery) Update(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the DropletLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (dropletLabelQuery) UpdateAll

func (q dropletLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (dropletLabelQuery) UpdateAllSlice

func (q dropletLabelQuery) UpdateAllSlice(o DropletLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (dropletLabelQuery) Upsert

func (q dropletLabelQuery) Upsert(o *DropletLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type dropletLabelR

dropletLabelR is where relationships are stored.

type dropletLabelR struct {
    Resource *Droplet `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*dropletLabelR) NewStruct

func (*dropletLabelR) NewStruct() *dropletLabelR

NewStruct creates a new relationship struct

type dropletQuery

type dropletQuery struct {
    *queries.Query
}

func Droplets

func Droplets(mods ...qm.QueryMod) dropletQuery

Droplets retrieves all the records using an executor.

func (dropletQuery) AddResourceDropletAnnotations

func (q dropletQuery) AddResourceDropletAnnotations(o *Droplet, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DropletAnnotation) error

AddResourceDropletAnnotations adds the given related objects to the existing relationships of the droplet\, optionally inserting them as new records. Appends related to o.R.ResourceDropletAnnotations. Sets related.R.Resource appropriately.

func (dropletQuery) AddResourceDropletLabels

func (q dropletQuery) AddResourceDropletLabels(o *Droplet, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DropletLabel) error

AddResourceDropletLabels adds the given related objects to the existing relationships of the droplet\, optionally inserting them as new records. Appends related to o.R.ResourceDropletLabels. Sets related.R.Resource appropriately.

func (dropletQuery) All

func (q dropletQuery) All(ctx context.Context, exec boil.ContextExecutor) (DropletSlice, error)

All returns all Droplet records from the query.

func (dropletQuery) App

func (q dropletQuery) App(o *Droplet, mods ...qm.QueryMod) appQuery

App pointed to by the foreign key.

func (dropletQuery) Count

func (q dropletQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Droplet records in the query.

func (dropletQuery) Delete

func (q dropletQuery) Delete(o *Droplet, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Droplet record with an executor. Delete will match against the primary key column to find the record to delete.

func (dropletQuery) DeleteAll

func (q dropletQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (dropletQuery) DeleteAllSlice

func (q dropletQuery) DeleteAllSlice(o DropletSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (dropletQuery) Exists

func (q dropletQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (dropletQuery) Insert

func (q dropletQuery) Insert(o *Droplet, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (dropletQuery) One

func (q dropletQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Droplet, error)

One returns a single droplet record from the query.

func (dropletQuery) Reload

func (q dropletQuery) Reload(o *Droplet, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (dropletQuery) ReloadAll

func (q dropletQuery) ReloadAll(o *DropletSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (dropletQuery) RemoveApp

func (q dropletQuery) RemoveApp(o *Droplet, ctx context.Context, exec boil.ContextExecutor, related *App) error

RemoveApp relationship. Sets o.R.App to nil. Removes o from all passed in related items' relationships struct (Optional).

func (dropletQuery) RemoveResourceDropletAnnotations

func (q dropletQuery) RemoveResourceDropletAnnotations(o *Droplet, ctx context.Context, exec boil.ContextExecutor, related ...*DropletAnnotation) error

RemoveResourceDropletAnnotations relationships from objects passed in. Removes related items from R.ResourceDropletAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (dropletQuery) RemoveResourceDropletLabels

func (q dropletQuery) RemoveResourceDropletLabels(o *Droplet, ctx context.Context, exec boil.ContextExecutor, related ...*DropletLabel) error

RemoveResourceDropletLabels relationships from objects passed in. Removes related items from R.ResourceDropletLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (dropletQuery) ResourceDropletAnnotations

func (q dropletQuery) ResourceDropletAnnotations(o *Droplet, mods ...qm.QueryMod) dropletAnnotationQuery

ResourceDropletAnnotations retrieves all the droplet_annotation's DropletAnnotations with an executor via resource_guid column.

func (dropletQuery) ResourceDropletLabels

func (q dropletQuery) ResourceDropletLabels(o *Droplet, mods ...qm.QueryMod) dropletLabelQuery

ResourceDropletLabels retrieves all the droplet_label's DropletLabels with an executor via resource_guid column.

func (dropletQuery) SetApp

func (q dropletQuery) SetApp(o *Droplet, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetApp of the droplet to the related item. Sets o.R.App to related. Adds o to related.R.Droplets.

func (dropletQuery) SetResourceDropletAnnotations

func (q dropletQuery) SetResourceDropletAnnotations(o *Droplet, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DropletAnnotation) error

SetResourceDropletAnnotations removes all previously related items of the droplet replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceDropletAnnotations accordingly. Replaces o.R.ResourceDropletAnnotations with related. Sets related.R.Resource's ResourceDropletAnnotations accordingly.

func (dropletQuery) SetResourceDropletLabels

func (q dropletQuery) SetResourceDropletLabels(o *Droplet, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*DropletLabel) error

SetResourceDropletLabels removes all previously related items of the droplet replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceDropletLabels accordingly. Replaces o.R.ResourceDropletLabels with related. Sets related.R.Resource's ResourceDropletLabels accordingly.

func (dropletQuery) Update

func (q dropletQuery) Update(o *Droplet, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Droplet. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (dropletQuery) UpdateAll

func (q dropletQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (dropletQuery) UpdateAllSlice

func (q dropletQuery) UpdateAllSlice(o DropletSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (dropletQuery) Upsert

func (q dropletQuery) Upsert(o *Droplet, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type dropletR

dropletR is where relationships are stored.

type dropletR struct {
    App                        *App                   `boil:"App" json:"App" toml:"App" yaml:"App"`
    ResourceDropletAnnotations DropletAnnotationSlice `boil:"ResourceDropletAnnotations" json:"ResourceDropletAnnotations" toml:"ResourceDropletAnnotations" yaml:"ResourceDropletAnnotations"`
    ResourceDropletLabels      DropletLabelSlice      `boil:"ResourceDropletLabels" json:"ResourceDropletLabels" toml:"ResourceDropletLabels" yaml:"ResourceDropletLabels"`
}

func (*dropletR) NewStruct

func (*dropletR) NewStruct() *dropletR

NewStruct creates a new relationship struct

type encryptionKeySentinelL

encryptionKeySentinelL is where Load methods for each relationship are stored.

type encryptionKeySentinelL struct{}

type encryptionKeySentinelQuery

type encryptionKeySentinelQuery struct {
    *queries.Query
}

func EncryptionKeySentinels

func EncryptionKeySentinels(mods ...qm.QueryMod) encryptionKeySentinelQuery

EncryptionKeySentinels retrieves all the records using an executor.

func (encryptionKeySentinelQuery) All

func (q encryptionKeySentinelQuery) All(ctx context.Context, exec boil.ContextExecutor) (EncryptionKeySentinelSlice, error)

All returns all EncryptionKeySentinel records from the query.

func (encryptionKeySentinelQuery) Count

func (q encryptionKeySentinelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all EncryptionKeySentinel records in the query.

func (encryptionKeySentinelQuery) Delete

func (q encryptionKeySentinelQuery) Delete(o *EncryptionKeySentinel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single EncryptionKeySentinel record with an executor. Delete will match against the primary key column to find the record to delete.

func (encryptionKeySentinelQuery) DeleteAll

func (q encryptionKeySentinelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (encryptionKeySentinelQuery) DeleteAllSlice

func (q encryptionKeySentinelQuery) DeleteAllSlice(o EncryptionKeySentinelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (encryptionKeySentinelQuery) Exists

func (q encryptionKeySentinelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (encryptionKeySentinelQuery) Insert

func (q encryptionKeySentinelQuery) Insert(o *EncryptionKeySentinel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (encryptionKeySentinelQuery) One

func (q encryptionKeySentinelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*EncryptionKeySentinel, error)

One returns a single encryptionKeySentinel record from the query.

func (encryptionKeySentinelQuery) Reload

func (q encryptionKeySentinelQuery) Reload(o *EncryptionKeySentinel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (encryptionKeySentinelQuery) ReloadAll

func (q encryptionKeySentinelQuery) ReloadAll(o *EncryptionKeySentinelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (encryptionKeySentinelQuery) Update

func (q encryptionKeySentinelQuery) Update(o *EncryptionKeySentinel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the EncryptionKeySentinel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (encryptionKeySentinelQuery) UpdateAll

func (q encryptionKeySentinelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (encryptionKeySentinelQuery) UpdateAllSlice

func (q encryptionKeySentinelQuery) UpdateAllSlice(o EncryptionKeySentinelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (encryptionKeySentinelQuery) Upsert

func (q encryptionKeySentinelQuery) Upsert(o *EncryptionKeySentinel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type encryptionKeySentinelR

encryptionKeySentinelR is where relationships are stored.

type encryptionKeySentinelR struct {
}

func (*encryptionKeySentinelR) NewStruct

func (*encryptionKeySentinelR) NewStruct() *encryptionKeySentinelR

NewStruct creates a new relationship struct

type envGroupL

envGroupL is where Load methods for each relationship are stored.

type envGroupL struct{}

type envGroupQuery

type envGroupQuery struct {
    *queries.Query
}

func EnvGroups

func EnvGroups(mods ...qm.QueryMod) envGroupQuery

EnvGroups retrieves all the records using an executor.

func (envGroupQuery) All

func (q envGroupQuery) All(ctx context.Context, exec boil.ContextExecutor) (EnvGroupSlice, error)

All returns all EnvGroup records from the query.

func (envGroupQuery) Count

func (q envGroupQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all EnvGroup records in the query.

func (envGroupQuery) Delete

func (q envGroupQuery) Delete(o *EnvGroup, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single EnvGroup record with an executor. Delete will match against the primary key column to find the record to delete.

func (envGroupQuery) DeleteAll

func (q envGroupQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (envGroupQuery) DeleteAllSlice

func (q envGroupQuery) DeleteAllSlice(o EnvGroupSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (envGroupQuery) Exists

func (q envGroupQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (envGroupQuery) Insert

func (q envGroupQuery) Insert(o *EnvGroup, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (envGroupQuery) One

func (q envGroupQuery) One(ctx context.Context, exec boil.ContextExecutor) (*EnvGroup, error)

One returns a single envGroup record from the query.

func (envGroupQuery) Reload

func (q envGroupQuery) Reload(o *EnvGroup, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (envGroupQuery) ReloadAll

func (q envGroupQuery) ReloadAll(o *EnvGroupSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (envGroupQuery) Update

func (q envGroupQuery) Update(o *EnvGroup, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the EnvGroup. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (envGroupQuery) UpdateAll

func (q envGroupQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (envGroupQuery) UpdateAllSlice

func (q envGroupQuery) UpdateAllSlice(o EnvGroupSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (envGroupQuery) Upsert

func (q envGroupQuery) Upsert(o *EnvGroup, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type envGroupR

envGroupR is where relationships are stored.

type envGroupR struct {
}

func (*envGroupR) NewStruct

func (*envGroupR) NewStruct() *envGroupR

NewStruct creates a new relationship struct

type eventL

eventL is where Load methods for each relationship are stored.

type eventL struct{}

type eventQuery

type eventQuery struct {
    *queries.Query
}

func Events

func Events(mods ...qm.QueryMod) eventQuery

Events retrieves all the records using an executor.

func (eventQuery) All

func (q eventQuery) All(ctx context.Context, exec boil.ContextExecutor) (EventSlice, error)

All returns all Event records from the query.

func (eventQuery) Count

func (q eventQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Event records in the query.

func (eventQuery) Delete

func (q eventQuery) Delete(o *Event, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Event record with an executor. Delete will match against the primary key column to find the record to delete.

func (eventQuery) DeleteAll

func (q eventQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (eventQuery) DeleteAllSlice

func (q eventQuery) DeleteAllSlice(o EventSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (eventQuery) Exists

func (q eventQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (eventQuery) Insert

func (q eventQuery) Insert(o *Event, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (eventQuery) One

func (q eventQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Event, error)

One returns a single event record from the query.

func (eventQuery) Reload

func (q eventQuery) Reload(o *Event, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (eventQuery) ReloadAll

func (q eventQuery) ReloadAll(o *EventSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (eventQuery) Update

func (q eventQuery) Update(o *Event, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Event. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (eventQuery) UpdateAll

func (q eventQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (eventQuery) UpdateAllSlice

func (q eventQuery) UpdateAllSlice(o EventSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (eventQuery) Upsert

func (q eventQuery) Upsert(o *Event, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type eventR

eventR is where relationships are stored.

type eventR struct {
}

func (*eventR) NewStruct

func (*eventR) NewStruct() *eventR

NewStruct creates a new relationship struct

type featureFlagL

featureFlagL is where Load methods for each relationship are stored.

type featureFlagL struct{}

type featureFlagQuery

type featureFlagQuery struct {
    *queries.Query
}

func FeatureFlags

func FeatureFlags(mods ...qm.QueryMod) featureFlagQuery

FeatureFlags retrieves all the records using an executor.

func (featureFlagQuery) All

func (q featureFlagQuery) All(ctx context.Context, exec boil.ContextExecutor) (FeatureFlagSlice, error)

All returns all FeatureFlag records from the query.

func (featureFlagQuery) Count

func (q featureFlagQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all FeatureFlag records in the query.

func (featureFlagQuery) Delete

func (q featureFlagQuery) Delete(o *FeatureFlag, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single FeatureFlag record with an executor. Delete will match against the primary key column to find the record to delete.

func (featureFlagQuery) DeleteAll

func (q featureFlagQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (featureFlagQuery) DeleteAllSlice

func (q featureFlagQuery) DeleteAllSlice(o FeatureFlagSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (featureFlagQuery) Exists

func (q featureFlagQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (featureFlagQuery) Insert

func (q featureFlagQuery) Insert(o *FeatureFlag, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (featureFlagQuery) One

func (q featureFlagQuery) One(ctx context.Context, exec boil.ContextExecutor) (*FeatureFlag, error)

One returns a single featureFlag record from the query.

func (featureFlagQuery) Reload

func (q featureFlagQuery) Reload(o *FeatureFlag, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (featureFlagQuery) ReloadAll

func (q featureFlagQuery) ReloadAll(o *FeatureFlagSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (featureFlagQuery) Update

func (q featureFlagQuery) Update(o *FeatureFlag, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the FeatureFlag. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (featureFlagQuery) UpdateAll

func (q featureFlagQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (featureFlagQuery) UpdateAllSlice

func (q featureFlagQuery) UpdateAllSlice(o FeatureFlagSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (featureFlagQuery) Upsert

func (q featureFlagQuery) Upsert(o *FeatureFlag, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type featureFlagR

featureFlagR is where relationships are stored.

type featureFlagR struct {
}

func (*featureFlagR) NewStruct

func (*featureFlagR) NewStruct() *featureFlagR

NewStruct creates a new relationship struct

type insertCache

type insertCache struct {
    query        string
    retQuery     string
    valueMapping []uint64
    retMapping   []uint64
}

type isolationSegmentAnnotationL

isolationSegmentAnnotationL is where Load methods for each relationship are stored.

type isolationSegmentAnnotationL struct{}

func (isolationSegmentAnnotationL) LoadResource

func (isolationSegmentAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeIsolationSegmentAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type isolationSegmentAnnotationQuery

type isolationSegmentAnnotationQuery struct {
    *queries.Query
}

func IsolationSegmentAnnotations

func IsolationSegmentAnnotations(mods ...qm.QueryMod) isolationSegmentAnnotationQuery

IsolationSegmentAnnotations retrieves all the records using an executor.

func (isolationSegmentAnnotationQuery) All

func (q isolationSegmentAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (IsolationSegmentAnnotationSlice, error)

All returns all IsolationSegmentAnnotation records from the query.

func (isolationSegmentAnnotationQuery) Count

func (q isolationSegmentAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all IsolationSegmentAnnotation records in the query.

func (isolationSegmentAnnotationQuery) Delete

func (q isolationSegmentAnnotationQuery) Delete(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single IsolationSegmentAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (isolationSegmentAnnotationQuery) DeleteAll

func (q isolationSegmentAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (isolationSegmentAnnotationQuery) DeleteAllSlice

func (q isolationSegmentAnnotationQuery) DeleteAllSlice(o IsolationSegmentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (isolationSegmentAnnotationQuery) Exists

func (q isolationSegmentAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (isolationSegmentAnnotationQuery) Insert

func (q isolationSegmentAnnotationQuery) Insert(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (isolationSegmentAnnotationQuery) One

func (q isolationSegmentAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*IsolationSegmentAnnotation, error)

One returns a single isolationSegmentAnnotation record from the query.

func (isolationSegmentAnnotationQuery) Reload

func (q isolationSegmentAnnotationQuery) Reload(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (isolationSegmentAnnotationQuery) ReloadAll

func (q isolationSegmentAnnotationQuery) ReloadAll(o *IsolationSegmentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (isolationSegmentAnnotationQuery) RemoveResource

func (q isolationSegmentAnnotationQuery) RemoveResource(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor, related *IsolationSegment) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (isolationSegmentAnnotationQuery) Resource

func (q isolationSegmentAnnotationQuery) Resource(o *IsolationSegmentAnnotation, mods ...qm.QueryMod) isolationSegmentQuery

Resource pointed to by the foreign key.

func (isolationSegmentAnnotationQuery) SetResource

func (q isolationSegmentAnnotationQuery) SetResource(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *IsolationSegment) error

SetResource of the isolationSegmentAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceIsolationSegmentAnnotations.

func (isolationSegmentAnnotationQuery) Update

func (q isolationSegmentAnnotationQuery) Update(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the IsolationSegmentAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (isolationSegmentAnnotationQuery) UpdateAll

func (q isolationSegmentAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (isolationSegmentAnnotationQuery) UpdateAllSlice

func (q isolationSegmentAnnotationQuery) UpdateAllSlice(o IsolationSegmentAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (isolationSegmentAnnotationQuery) Upsert

func (q isolationSegmentAnnotationQuery) Upsert(o *IsolationSegmentAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type isolationSegmentAnnotationR

isolationSegmentAnnotationR is where relationships are stored.

type isolationSegmentAnnotationR struct {
    Resource *IsolationSegment `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*isolationSegmentAnnotationR) NewStruct

func (*isolationSegmentAnnotationR) NewStruct() *isolationSegmentAnnotationR

NewStruct creates a new relationship struct

type isolationSegmentL

isolationSegmentL is where Load methods for each relationship are stored.

type isolationSegmentL struct{}

func (isolationSegmentL) LoadOrganizations

func (isolationSegmentL) LoadOrganizations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeIsolationSegment interface{}, mods queries.Applicator) error

LoadOrganizations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (isolationSegmentL) LoadResourceIsolationSegmentAnnotations

func (isolationSegmentL) LoadResourceIsolationSegmentAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeIsolationSegment interface{}, mods queries.Applicator) error

LoadResourceIsolationSegmentAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (isolationSegmentL) LoadResourceIsolationSegmentLabels

func (isolationSegmentL) LoadResourceIsolationSegmentLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeIsolationSegment interface{}, mods queries.Applicator) error

LoadResourceIsolationSegmentLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (isolationSegmentL) LoadSpaces

func (isolationSegmentL) LoadSpaces(ctx context.Context, e boil.ContextExecutor, singular bool, maybeIsolationSegment interface{}, mods queries.Applicator) error

LoadSpaces allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type isolationSegmentLabelL

isolationSegmentLabelL is where Load methods for each relationship are stored.

type isolationSegmentLabelL struct{}

func (isolationSegmentLabelL) LoadResource

func (isolationSegmentLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeIsolationSegmentLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type isolationSegmentLabelQuery

type isolationSegmentLabelQuery struct {
    *queries.Query
}

func IsolationSegmentLabels

func IsolationSegmentLabels(mods ...qm.QueryMod) isolationSegmentLabelQuery

IsolationSegmentLabels retrieves all the records using an executor.

func (isolationSegmentLabelQuery) All

func (q isolationSegmentLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (IsolationSegmentLabelSlice, error)

All returns all IsolationSegmentLabel records from the query.

func (isolationSegmentLabelQuery) Count

func (q isolationSegmentLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all IsolationSegmentLabel records in the query.

func (isolationSegmentLabelQuery) Delete

func (q isolationSegmentLabelQuery) Delete(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single IsolationSegmentLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (isolationSegmentLabelQuery) DeleteAll

func (q isolationSegmentLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (isolationSegmentLabelQuery) DeleteAllSlice

func (q isolationSegmentLabelQuery) DeleteAllSlice(o IsolationSegmentLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (isolationSegmentLabelQuery) Exists

func (q isolationSegmentLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (isolationSegmentLabelQuery) Insert

func (q isolationSegmentLabelQuery) Insert(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (isolationSegmentLabelQuery) One

func (q isolationSegmentLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*IsolationSegmentLabel, error)

One returns a single isolationSegmentLabel record from the query.

func (isolationSegmentLabelQuery) Reload

func (q isolationSegmentLabelQuery) Reload(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (isolationSegmentLabelQuery) ReloadAll

func (q isolationSegmentLabelQuery) ReloadAll(o *IsolationSegmentLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (isolationSegmentLabelQuery) RemoveResource

func (q isolationSegmentLabelQuery) RemoveResource(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor, related *IsolationSegment) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (isolationSegmentLabelQuery) Resource

func (q isolationSegmentLabelQuery) Resource(o *IsolationSegmentLabel, mods ...qm.QueryMod) isolationSegmentQuery

Resource pointed to by the foreign key.

func (isolationSegmentLabelQuery) SetResource

func (q isolationSegmentLabelQuery) SetResource(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *IsolationSegment) error

SetResource of the isolationSegmentLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceIsolationSegmentLabels.

func (isolationSegmentLabelQuery) Update

func (q isolationSegmentLabelQuery) Update(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the IsolationSegmentLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (isolationSegmentLabelQuery) UpdateAll

func (q isolationSegmentLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (isolationSegmentLabelQuery) UpdateAllSlice

func (q isolationSegmentLabelQuery) UpdateAllSlice(o IsolationSegmentLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (isolationSegmentLabelQuery) Upsert

func (q isolationSegmentLabelQuery) Upsert(o *IsolationSegmentLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type isolationSegmentLabelR

isolationSegmentLabelR is where relationships are stored.

type isolationSegmentLabelR struct {
    Resource *IsolationSegment `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*isolationSegmentLabelR) NewStruct

func (*isolationSegmentLabelR) NewStruct() *isolationSegmentLabelR

NewStruct creates a new relationship struct

type isolationSegmentQuery

type isolationSegmentQuery struct {
    *queries.Query
}

func IsolationSegments

func IsolationSegments(mods ...qm.QueryMod) isolationSegmentQuery

IsolationSegments retrieves all the records using an executor.

func (isolationSegmentQuery) AddOrganizations

func (q isolationSegmentQuery) AddOrganizations(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Organization) error

AddOrganizations adds the given related objects to the existing relationships of the isolation_segment\, optionally inserting them as new records. Appends related to o.R.Organizations. Sets related.R.IsolationSegments appropriately.

func (isolationSegmentQuery) AddResourceIsolationSegmentAnnotations

func (q isolationSegmentQuery) AddResourceIsolationSegmentAnnotations(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*IsolationSegmentAnnotation) error

AddResourceIsolationSegmentAnnotations adds the given related objects to the existing relationships of the isolation_segment\, optionally inserting them as new records. Appends related to o.R.ResourceIsolationSegmentAnnotations. Sets related.R.Resource appropriately.

func (isolationSegmentQuery) AddResourceIsolationSegmentLabels

func (q isolationSegmentQuery) AddResourceIsolationSegmentLabels(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*IsolationSegmentLabel) error

AddResourceIsolationSegmentLabels adds the given related objects to the existing relationships of the isolation_segment\, optionally inserting them as new records. Appends related to o.R.ResourceIsolationSegmentLabels. Sets related.R.Resource appropriately.

func (isolationSegmentQuery) AddSpaces

func (q isolationSegmentQuery) AddSpaces(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Space) error

AddSpaces adds the given related objects to the existing relationships of the isolation_segment\, optionally inserting them as new records. Appends related to o.R.Spaces. Sets related.R.IsolationSegment appropriately.

func (isolationSegmentQuery) All

func (q isolationSegmentQuery) All(ctx context.Context, exec boil.ContextExecutor) (IsolationSegmentSlice, error)

All returns all IsolationSegment records from the query.

func (isolationSegmentQuery) Count

func (q isolationSegmentQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all IsolationSegment records in the query.

func (isolationSegmentQuery) Delete

func (q isolationSegmentQuery) Delete(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single IsolationSegment record with an executor. Delete will match against the primary key column to find the record to delete.

func (isolationSegmentQuery) DeleteAll

func (q isolationSegmentQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (isolationSegmentQuery) DeleteAllSlice

func (q isolationSegmentQuery) DeleteAllSlice(o IsolationSegmentSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (isolationSegmentQuery) Exists

func (q isolationSegmentQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (isolationSegmentQuery) Insert

func (q isolationSegmentQuery) Insert(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (isolationSegmentQuery) One

func (q isolationSegmentQuery) One(ctx context.Context, exec boil.ContextExecutor) (*IsolationSegment, error)

One returns a single isolationSegment record from the query.

func (isolationSegmentQuery) Organizations

func (q isolationSegmentQuery) Organizations(o *IsolationSegment, mods ...qm.QueryMod) organizationQuery

Organizations retrieves all the organization's Organizations with an executor.

func (isolationSegmentQuery) Reload

func (q isolationSegmentQuery) Reload(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (isolationSegmentQuery) ReloadAll

func (q isolationSegmentQuery) ReloadAll(o *IsolationSegmentSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (isolationSegmentQuery) RemoveOrganizations

func (q isolationSegmentQuery) RemoveOrganizations(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, related ...*Organization) error

RemoveOrganizations relationships from objects passed in. Removes related items from R.Organizations (uses pointer comparison\, removal does not keep order) Sets related.R.IsolationSegments.

func (isolationSegmentQuery) RemoveResourceIsolationSegmentAnnotations

func (q isolationSegmentQuery) RemoveResourceIsolationSegmentAnnotations(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, related ...*IsolationSegmentAnnotation) error

RemoveResourceIsolationSegmentAnnotations relationships from objects passed in. Removes related items from R.ResourceIsolationSegmentAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (isolationSegmentQuery) RemoveResourceIsolationSegmentLabels

func (q isolationSegmentQuery) RemoveResourceIsolationSegmentLabels(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, related ...*IsolationSegmentLabel) error

RemoveResourceIsolationSegmentLabels relationships from objects passed in. Removes related items from R.ResourceIsolationSegmentLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (isolationSegmentQuery) RemoveSpaces

func (q isolationSegmentQuery) RemoveSpaces(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, related ...*Space) error

RemoveSpaces relationships from objects passed in. Removes related items from R.Spaces (uses pointer comparison\, removal does not keep order) Sets related.R.IsolationSegment.

func (isolationSegmentQuery) ResourceIsolationSegmentAnnotations

func (q isolationSegmentQuery) ResourceIsolationSegmentAnnotations(o *IsolationSegment, mods ...qm.QueryMod) isolationSegmentAnnotationQuery

ResourceIsolationSegmentAnnotations retrieves all the isolation_segment_annotation's IsolationSegmentAnnotations with an executor via resource_guid column.

func (isolationSegmentQuery) ResourceIsolationSegmentLabels

func (q isolationSegmentQuery) ResourceIsolationSegmentLabels(o *IsolationSegment, mods ...qm.QueryMod) isolationSegmentLabelQuery

ResourceIsolationSegmentLabels retrieves all the isolation_segment_label's IsolationSegmentLabels with an executor via resource_guid column.

func (isolationSegmentQuery) SetOrganizations

func (q isolationSegmentQuery) SetOrganizations(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Organization) error

SetOrganizations removes all previously related items of the isolation_segment replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.IsolationSegments's Organizations accordingly. Replaces o.R.Organizations with related. Sets related.R.IsolationSegments's Organizations accordingly.

func (isolationSegmentQuery) SetResourceIsolationSegmentAnnotations

func (q isolationSegmentQuery) SetResourceIsolationSegmentAnnotations(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*IsolationSegmentAnnotation) error

SetResourceIsolationSegmentAnnotations removes all previously related items of the isolation_segment replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceIsolationSegmentAnnotations accordingly. Replaces o.R.ResourceIsolationSegmentAnnotations with related. Sets related.R.Resource's ResourceIsolationSegmentAnnotations accordingly.

func (isolationSegmentQuery) SetResourceIsolationSegmentLabels

func (q isolationSegmentQuery) SetResourceIsolationSegmentLabels(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*IsolationSegmentLabel) error

SetResourceIsolationSegmentLabels removes all previously related items of the isolation_segment replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceIsolationSegmentLabels accordingly. Replaces o.R.ResourceIsolationSegmentLabels with related. Sets related.R.Resource's ResourceIsolationSegmentLabels accordingly.

func (isolationSegmentQuery) SetSpaces

func (q isolationSegmentQuery) SetSpaces(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Space) error

SetSpaces removes all previously related items of the isolation_segment replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.IsolationSegment's Spaces accordingly. Replaces o.R.Spaces with related. Sets related.R.IsolationSegment's Spaces accordingly.

func (isolationSegmentQuery) Spaces

func (q isolationSegmentQuery) Spaces(o *IsolationSegment, mods ...qm.QueryMod) spaceQuery

Spaces retrieves all the space's Spaces with an executor.

func (isolationSegmentQuery) Update

func (q isolationSegmentQuery) Update(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the IsolationSegment. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (isolationSegmentQuery) UpdateAll

func (q isolationSegmentQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (isolationSegmentQuery) UpdateAllSlice

func (q isolationSegmentQuery) UpdateAllSlice(o IsolationSegmentSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (isolationSegmentQuery) Upsert

func (q isolationSegmentQuery) Upsert(o *IsolationSegment, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type isolationSegmentR

isolationSegmentR is where relationships are stored.

type isolationSegmentR struct {
    ResourceIsolationSegmentAnnotations IsolationSegmentAnnotationSlice `boil:"ResourceIsolationSegmentAnnotations" json:"ResourceIsolationSegmentAnnotations" toml:"ResourceIsolationSegmentAnnotations" yaml:"ResourceIsolationSegmentAnnotations"`
    ResourceIsolationSegmentLabels      IsolationSegmentLabelSlice      `boil:"ResourceIsolationSegmentLabels" json:"ResourceIsolationSegmentLabels" toml:"ResourceIsolationSegmentLabels" yaml:"ResourceIsolationSegmentLabels"`
    Organizations                       OrganizationSlice               `boil:"Organizations" json:"Organizations" toml:"Organizations" yaml:"Organizations"`
    Spaces                              SpaceSlice                      `boil:"Spaces" json:"Spaces" toml:"Spaces" yaml:"Spaces"`
}

func (*isolationSegmentR) NewStruct

func (*isolationSegmentR) NewStruct() *isolationSegmentR

NewStruct creates a new relationship struct

type jobL

jobL is where Load methods for each relationship are stored.

type jobL struct{}

func (jobL) LoadFKJobJobWarnings

func (jobL) LoadFKJobJobWarnings(ctx context.Context, e boil.ContextExecutor, singular bool, maybeJob interface{}, mods queries.Applicator) error

LoadFKJobJobWarnings allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type jobQuery

type jobQuery struct {
    *queries.Query
}

func Jobs

func Jobs(mods ...qm.QueryMod) jobQuery

Jobs retrieves all the records using an executor.

func (jobQuery) AddFKJobJobWarnings

func (q jobQuery) AddFKJobJobWarnings(o *Job, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*JobWarning) error

AddFKJobJobWarnings adds the given related objects to the existing relationships of the job\, optionally inserting them as new records. Appends related to o.R.FKJobJobWarnings. Sets related.R.FKJob appropriately.

func (jobQuery) All

func (q jobQuery) All(ctx context.Context, exec boil.ContextExecutor) (JobSlice, error)

All returns all Job records from the query.

func (jobQuery) Count

func (q jobQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Job records in the query.

func (jobQuery) Delete

func (q jobQuery) Delete(o *Job, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Job record with an executor. Delete will match against the primary key column to find the record to delete.

func (jobQuery) DeleteAll

func (q jobQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (jobQuery) DeleteAllSlice

func (q jobQuery) DeleteAllSlice(o JobSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (jobQuery) Exists

func (q jobQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (jobQuery) FKJobJobWarnings

func (q jobQuery) FKJobJobWarnings(o *Job, mods ...qm.QueryMod) jobWarningQuery

FKJobJobWarnings retrieves all the job_warning's JobWarnings with an executor via fk_jobs_id column.

func (jobQuery) Insert

func (q jobQuery) Insert(o *Job, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (jobQuery) One

func (q jobQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Job, error)

One returns a single job record from the query.

func (jobQuery) Reload

func (q jobQuery) Reload(o *Job, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (jobQuery) ReloadAll

func (q jobQuery) ReloadAll(o *JobSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (jobQuery) RemoveFKJobJobWarnings

func (q jobQuery) RemoveFKJobJobWarnings(o *Job, ctx context.Context, exec boil.ContextExecutor, related ...*JobWarning) error

RemoveFKJobJobWarnings relationships from objects passed in. Removes related items from R.FKJobJobWarnings (uses pointer comparison\, removal does not keep order) Sets related.R.FKJob.

func (jobQuery) SetFKJobJobWarnings

func (q jobQuery) SetFKJobJobWarnings(o *Job, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*JobWarning) error

SetFKJobJobWarnings removes all previously related items of the job replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.FKJob's FKJobJobWarnings accordingly. Replaces o.R.FKJobJobWarnings with related. Sets related.R.FKJob's FKJobJobWarnings accordingly.

func (jobQuery) Update

func (q jobQuery) Update(o *Job, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Job. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (jobQuery) UpdateAll

func (q jobQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (jobQuery) UpdateAllSlice

func (q jobQuery) UpdateAllSlice(o JobSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (jobQuery) Upsert

func (q jobQuery) Upsert(o *Job, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type jobR

jobR is where relationships are stored.

type jobR struct {
    FKJobJobWarnings JobWarningSlice `boil:"FKJobJobWarnings" json:"FKJobJobWarnings" toml:"FKJobJobWarnings" yaml:"FKJobJobWarnings"`
}

func (*jobR) NewStruct

func (*jobR) NewStruct() *jobR

NewStruct creates a new relationship struct

type jobWarningL

jobWarningL is where Load methods for each relationship are stored.

type jobWarningL struct{}

func (jobWarningL) LoadFKJob

func (jobWarningL) LoadFKJob(ctx context.Context, e boil.ContextExecutor, singular bool, maybeJobWarning interface{}, mods queries.Applicator) error

LoadFKJob allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type jobWarningQuery

type jobWarningQuery struct {
    *queries.Query
}

func JobWarnings

func JobWarnings(mods ...qm.QueryMod) jobWarningQuery

JobWarnings retrieves all the records using an executor.

func (jobWarningQuery) All

func (q jobWarningQuery) All(ctx context.Context, exec boil.ContextExecutor) (JobWarningSlice, error)

All returns all JobWarning records from the query.

func (jobWarningQuery) Count

func (q jobWarningQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all JobWarning records in the query.

func (jobWarningQuery) Delete

func (q jobWarningQuery) Delete(o *JobWarning, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single JobWarning record with an executor. Delete will match against the primary key column to find the record to delete.

func (jobWarningQuery) DeleteAll

func (q jobWarningQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (jobWarningQuery) DeleteAllSlice

func (q jobWarningQuery) DeleteAllSlice(o JobWarningSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (jobWarningQuery) Exists

func (q jobWarningQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (jobWarningQuery) FKJob

func (q jobWarningQuery) FKJob(o *JobWarning, mods ...qm.QueryMod) jobQuery

FKJob pointed to by the foreign key.

func (jobWarningQuery) Insert

func (q jobWarningQuery) Insert(o *JobWarning, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (jobWarningQuery) One

func (q jobWarningQuery) One(ctx context.Context, exec boil.ContextExecutor) (*JobWarning, error)

One returns a single jobWarning record from the query.

func (jobWarningQuery) Reload

func (q jobWarningQuery) Reload(o *JobWarning, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (jobWarningQuery) ReloadAll

func (q jobWarningQuery) ReloadAll(o *JobWarningSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (jobWarningQuery) RemoveFKJob

func (q jobWarningQuery) RemoveFKJob(o *JobWarning, ctx context.Context, exec boil.ContextExecutor, related *Job) error

RemoveFKJob relationship. Sets o.R.FKJob to nil. Removes o from all passed in related items' relationships struct (Optional).

func (jobWarningQuery) SetFKJob

func (q jobWarningQuery) SetFKJob(o *JobWarning, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Job) error

SetFKJob of the jobWarning to the related item. Sets o.R.FKJob to related. Adds o to related.R.FKJobJobWarnings.

func (jobWarningQuery) Update

func (q jobWarningQuery) Update(o *JobWarning, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the JobWarning. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (jobWarningQuery) UpdateAll

func (q jobWarningQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (jobWarningQuery) UpdateAllSlice

func (q jobWarningQuery) UpdateAllSlice(o JobWarningSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (jobWarningQuery) Upsert

func (q jobWarningQuery) Upsert(o *JobWarning, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type jobWarningR

jobWarningR is where relationships are stored.

type jobWarningR struct {
    FKJob *Job `boil:"FKJob" json:"FKJob" toml:"FKJob" yaml:"FKJob"`
}

func (*jobWarningR) NewStruct

func (*jobWarningR) NewStruct() *jobWarningR

NewStruct creates a new relationship struct

type kpackLifecycleDatumL

kpackLifecycleDatumL is where Load methods for each relationship are stored.

type kpackLifecycleDatumL struct{}

func (kpackLifecycleDatumL) LoadApp

func (kpackLifecycleDatumL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybeKpackLifecycleDatum interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (kpackLifecycleDatumL) LoadBuild

func (kpackLifecycleDatumL) LoadBuild(ctx context.Context, e boil.ContextExecutor, singular bool, maybeKpackLifecycleDatum interface{}, mods queries.Applicator) error

LoadBuild allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type kpackLifecycleDatumQuery

type kpackLifecycleDatumQuery struct {
    *queries.Query
}

func KpackLifecycleData

func KpackLifecycleData(mods ...qm.QueryMod) kpackLifecycleDatumQuery

KpackLifecycleData retrieves all the records using an executor.

func (kpackLifecycleDatumQuery) All

func (q kpackLifecycleDatumQuery) All(ctx context.Context, exec boil.ContextExecutor) (KpackLifecycleDatumSlice, error)

All returns all KpackLifecycleDatum records from the query.

func (kpackLifecycleDatumQuery) App

func (q kpackLifecycleDatumQuery) App(o *KpackLifecycleDatum, mods ...qm.QueryMod) appQuery

App pointed to by the foreign key.

func (kpackLifecycleDatumQuery) Build

func (q kpackLifecycleDatumQuery) Build(o *KpackLifecycleDatum, mods ...qm.QueryMod) buildQuery

Build pointed to by the foreign key.

func (kpackLifecycleDatumQuery) Count

func (q kpackLifecycleDatumQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all KpackLifecycleDatum records in the query.

func (kpackLifecycleDatumQuery) Delete

func (q kpackLifecycleDatumQuery) Delete(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single KpackLifecycleDatum record with an executor. Delete will match against the primary key column to find the record to delete.

func (kpackLifecycleDatumQuery) DeleteAll

func (q kpackLifecycleDatumQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (kpackLifecycleDatumQuery) DeleteAllSlice

func (q kpackLifecycleDatumQuery) DeleteAllSlice(o KpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (kpackLifecycleDatumQuery) Exists

func (q kpackLifecycleDatumQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (kpackLifecycleDatumQuery) Insert

func (q kpackLifecycleDatumQuery) Insert(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (kpackLifecycleDatumQuery) One

func (q kpackLifecycleDatumQuery) One(ctx context.Context, exec boil.ContextExecutor) (*KpackLifecycleDatum, error)

One returns a single kpackLifecycleDatum record from the query.

func (kpackLifecycleDatumQuery) Reload

func (q kpackLifecycleDatumQuery) Reload(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (kpackLifecycleDatumQuery) ReloadAll

func (q kpackLifecycleDatumQuery) ReloadAll(o *KpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (kpackLifecycleDatumQuery) RemoveApp

func (q kpackLifecycleDatumQuery) RemoveApp(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, related *App) error

RemoveApp relationship. Sets o.R.App to nil. Removes o from all passed in related items' relationships struct (Optional).

func (kpackLifecycleDatumQuery) RemoveBuild

func (q kpackLifecycleDatumQuery) RemoveBuild(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, related *Build) error

RemoveBuild relationship. Sets o.R.Build to nil. Removes o from all passed in related items' relationships struct (Optional).

func (kpackLifecycleDatumQuery) SetApp

func (q kpackLifecycleDatumQuery) SetApp(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetApp of the kpackLifecycleDatum to the related item. Sets o.R.App to related. Adds o to related.R.KpackLifecycleData.

func (kpackLifecycleDatumQuery) SetBuild

func (q kpackLifecycleDatumQuery) SetBuild(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Build) error

SetBuild of the kpackLifecycleDatum to the related item. Sets o.R.Build to related. Adds o to related.R.KpackLifecycleData.

func (kpackLifecycleDatumQuery) Update

func (q kpackLifecycleDatumQuery) Update(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the KpackLifecycleDatum. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (kpackLifecycleDatumQuery) UpdateAll

func (q kpackLifecycleDatumQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (kpackLifecycleDatumQuery) UpdateAllSlice

func (q kpackLifecycleDatumQuery) UpdateAllSlice(o KpackLifecycleDatumSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (kpackLifecycleDatumQuery) Upsert

func (q kpackLifecycleDatumQuery) Upsert(o *KpackLifecycleDatum, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type kpackLifecycleDatumR

kpackLifecycleDatumR is where relationships are stored.

type kpackLifecycleDatumR struct {
    App   *App   `boil:"App" json:"App" toml:"App" yaml:"App"`
    Build *Build `boil:"Build" json:"Build" toml:"Build" yaml:"Build"`
}

func (*kpackLifecycleDatumR) NewStruct

func (*kpackLifecycleDatumR) NewStruct() *kpackLifecycleDatumR

NewStruct creates a new relationship struct

type lockingL

lockingL is where Load methods for each relationship are stored.

type lockingL struct{}

type lockingQuery

type lockingQuery struct {
    *queries.Query
}

func Lockings

func Lockings(mods ...qm.QueryMod) lockingQuery

Lockings retrieves all the records using an executor.

func (lockingQuery) All

func (q lockingQuery) All(ctx context.Context, exec boil.ContextExecutor) (LockingSlice, error)

All returns all Locking records from the query.

func (lockingQuery) Count

func (q lockingQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Locking records in the query.

func (lockingQuery) Delete

func (q lockingQuery) Delete(o *Locking, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Locking record with an executor. Delete will match against the primary key column to find the record to delete.

func (lockingQuery) DeleteAll

func (q lockingQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (lockingQuery) DeleteAllSlice

func (q lockingQuery) DeleteAllSlice(o LockingSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (lockingQuery) Exists

func (q lockingQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (lockingQuery) Insert

func (q lockingQuery) Insert(o *Locking, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (lockingQuery) One

func (q lockingQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Locking, error)

One returns a single locking record from the query.

func (lockingQuery) Reload

func (q lockingQuery) Reload(o *Locking, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (lockingQuery) ReloadAll

func (q lockingQuery) ReloadAll(o *LockingSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (lockingQuery) Update

func (q lockingQuery) Update(o *Locking, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Locking. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (lockingQuery) UpdateAll

func (q lockingQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (lockingQuery) UpdateAllSlice

func (q lockingQuery) UpdateAllSlice(o LockingSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (lockingQuery) Upsert

func (q lockingQuery) Upsert(o *Locking, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type lockingR

lockingR is where relationships are stored.

type lockingR struct {
}

func (*lockingR) NewStruct

func (*lockingR) NewStruct() *lockingR

NewStruct creates a new relationship struct

type organizationAnnotationL

organizationAnnotationL is where Load methods for each relationship are stored.

type organizationAnnotationL struct{}

func (organizationAnnotationL) LoadResource

func (organizationAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type organizationAnnotationQuery

type organizationAnnotationQuery struct {
    *queries.Query
}

func OrganizationAnnotations

func OrganizationAnnotations(mods ...qm.QueryMod) organizationAnnotationQuery

OrganizationAnnotations retrieves all the records using an executor.

func (organizationAnnotationQuery) All

func (q organizationAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (OrganizationAnnotationSlice, error)

All returns all OrganizationAnnotation records from the query.

func (organizationAnnotationQuery) Count

func (q organizationAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all OrganizationAnnotation records in the query.

func (organizationAnnotationQuery) Delete

func (q organizationAnnotationQuery) Delete(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single OrganizationAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (organizationAnnotationQuery) DeleteAll

func (q organizationAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (organizationAnnotationQuery) DeleteAllSlice

func (q organizationAnnotationQuery) DeleteAllSlice(o OrganizationAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (organizationAnnotationQuery) Exists

func (q organizationAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (organizationAnnotationQuery) Insert

func (q organizationAnnotationQuery) Insert(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (organizationAnnotationQuery) One

func (q organizationAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationAnnotation, error)

One returns a single organizationAnnotation record from the query.

func (organizationAnnotationQuery) Reload

func (q organizationAnnotationQuery) Reload(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (organizationAnnotationQuery) ReloadAll

func (q organizationAnnotationQuery) ReloadAll(o *OrganizationAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (organizationAnnotationQuery) RemoveResource

func (q organizationAnnotationQuery) RemoveResource(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Organization) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (organizationAnnotationQuery) Resource

func (q organizationAnnotationQuery) Resource(o *OrganizationAnnotation, mods ...qm.QueryMod) organizationQuery

Resource pointed to by the foreign key.

func (organizationAnnotationQuery) SetResource

func (q organizationAnnotationQuery) SetResource(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Organization) error

SetResource of the organizationAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceOrganizationAnnotations.

func (organizationAnnotationQuery) Update

func (q organizationAnnotationQuery) Update(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the OrganizationAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (organizationAnnotationQuery) UpdateAll

func (q organizationAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (organizationAnnotationQuery) UpdateAllSlice

func (q organizationAnnotationQuery) UpdateAllSlice(o OrganizationAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (organizationAnnotationQuery) Upsert

func (q organizationAnnotationQuery) Upsert(o *OrganizationAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type organizationAnnotationR

organizationAnnotationR is where relationships are stored.

type organizationAnnotationR struct {
    Resource *Organization `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*organizationAnnotationR) NewStruct

func (*organizationAnnotationR) NewStruct() *organizationAnnotationR

NewStruct creates a new relationship struct

type organizationL

organizationL is where Load methods for each relationship are stored.

type organizationL struct{}

func (organizationL) LoadIsolationSegments

func (organizationL) LoadIsolationSegments(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadIsolationSegments allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (organizationL) LoadOrganizationsAuditors

func (organizationL) LoadOrganizationsAuditors(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadOrganizationsAuditors allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (organizationL) LoadOrganizationsBillingManagers

func (organizationL) LoadOrganizationsBillingManagers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadOrganizationsBillingManagers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (organizationL) LoadOrganizationsManagers

func (organizationL) LoadOrganizationsManagers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadOrganizationsManagers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (organizationL) LoadOrganizationsPrivateDomains

func (organizationL) LoadOrganizationsPrivateDomains(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadOrganizationsPrivateDomains allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (organizationL) LoadOrganizationsUsers

func (organizationL) LoadOrganizationsUsers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadOrganizationsUsers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (organizationL) LoadOwningOrganizationDomains

func (organizationL) LoadOwningOrganizationDomains(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadOwningOrganizationDomains allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (organizationL) LoadQuotaDefinition

func (organizationL) LoadQuotaDefinition(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadQuotaDefinition allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (organizationL) LoadResourceOrganizationAnnotations

func (organizationL) LoadResourceOrganizationAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadResourceOrganizationAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (organizationL) LoadResourceOrganizationLabels

func (organizationL) LoadResourceOrganizationLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadResourceOrganizationLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (organizationL) LoadServicePlanVisibilities

func (organizationL) LoadServicePlanVisibilities(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadServicePlanVisibilities allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (organizationL) LoadSpaceQuotaDefinitions

func (organizationL) LoadSpaceQuotaDefinitions(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadSpaceQuotaDefinitions allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (organizationL) LoadSpaces

func (organizationL) LoadSpaces(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganization interface{}, mods queries.Applicator) error

LoadSpaces allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type organizationLabelL

organizationLabelL is where Load methods for each relationship are stored.

type organizationLabelL struct{}

func (organizationLabelL) LoadResource

func (organizationLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type organizationLabelQuery

type organizationLabelQuery struct {
    *queries.Query
}

func OrganizationLabels

func OrganizationLabels(mods ...qm.QueryMod) organizationLabelQuery

OrganizationLabels retrieves all the records using an executor.

func (organizationLabelQuery) All

func (q organizationLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (OrganizationLabelSlice, error)

All returns all OrganizationLabel records from the query.

func (organizationLabelQuery) Count

func (q organizationLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all OrganizationLabel records in the query.

func (organizationLabelQuery) Delete

func (q organizationLabelQuery) Delete(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single OrganizationLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (organizationLabelQuery) DeleteAll

func (q organizationLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (organizationLabelQuery) DeleteAllSlice

func (q organizationLabelQuery) DeleteAllSlice(o OrganizationLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (organizationLabelQuery) Exists

func (q organizationLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (organizationLabelQuery) Insert

func (q organizationLabelQuery) Insert(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (organizationLabelQuery) One

func (q organizationLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationLabel, error)

One returns a single organizationLabel record from the query.

func (organizationLabelQuery) Reload

func (q organizationLabelQuery) Reload(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (organizationLabelQuery) ReloadAll

func (q organizationLabelQuery) ReloadAll(o *OrganizationLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (organizationLabelQuery) RemoveResource

func (q organizationLabelQuery) RemoveResource(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor, related *Organization) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (organizationLabelQuery) Resource

func (q organizationLabelQuery) Resource(o *OrganizationLabel, mods ...qm.QueryMod) organizationQuery

Resource pointed to by the foreign key.

func (organizationLabelQuery) SetResource

func (q organizationLabelQuery) SetResource(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Organization) error

SetResource of the organizationLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceOrganizationLabels.

func (organizationLabelQuery) Update

func (q organizationLabelQuery) Update(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the OrganizationLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (organizationLabelQuery) UpdateAll

func (q organizationLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (organizationLabelQuery) UpdateAllSlice

func (q organizationLabelQuery) UpdateAllSlice(o OrganizationLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (organizationLabelQuery) Upsert

func (q organizationLabelQuery) Upsert(o *OrganizationLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type organizationLabelR

organizationLabelR is where relationships are stored.

type organizationLabelR struct {
    Resource *Organization `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*organizationLabelR) NewStruct

func (*organizationLabelR) NewStruct() *organizationLabelR

NewStruct creates a new relationship struct

type organizationQuery

type organizationQuery struct {
    *queries.Query
}

func Organizations

func Organizations(mods ...qm.QueryMod) organizationQuery

Organizations retrieves all the records using an executor.

func (organizationQuery) AddIsolationSegments

func (q organizationQuery) AddIsolationSegments(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*IsolationSegment) error

AddIsolationSegments adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.IsolationSegments. Sets related.R.Organizations appropriately.

func (organizationQuery) AddOrganizationsAuditors

func (q organizationQuery) AddOrganizationsAuditors(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationsAuditor) error

AddOrganizationsAuditors adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.OrganizationsAuditors. Sets related.R.Organization appropriately.

func (organizationQuery) AddOrganizationsBillingManagers

func (q organizationQuery) AddOrganizationsBillingManagers(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationsBillingManager) error

AddOrganizationsBillingManagers adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.OrganizationsBillingManagers. Sets related.R.Organization appropriately.

func (organizationQuery) AddOrganizationsManagers

func (q organizationQuery) AddOrganizationsManagers(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationsManager) error

AddOrganizationsManagers adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.OrganizationsManagers. Sets related.R.Organization appropriately.

func (organizationQuery) AddOrganizationsPrivateDomains

func (q organizationQuery) AddOrganizationsPrivateDomains(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationsPrivateDomain) error

AddOrganizationsPrivateDomains adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.OrganizationsPrivateDomains. Sets related.R.Organization appropriately.

func (organizationQuery) AddOrganizationsUsers

func (q organizationQuery) AddOrganizationsUsers(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationsUser) error

AddOrganizationsUsers adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.OrganizationsUsers. Sets related.R.Organization appropriately.

func (organizationQuery) AddOwningOrganizationDomains

func (q organizationQuery) AddOwningOrganizationDomains(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Domain) error

AddOwningOrganizationDomains adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.OwningOrganizationDomains. Sets related.R.OwningOrganization appropriately.

func (organizationQuery) AddResourceOrganizationAnnotations

func (q organizationQuery) AddResourceOrganizationAnnotations(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationAnnotation) error

AddResourceOrganizationAnnotations adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.ResourceOrganizationAnnotations. Sets related.R.Resource appropriately.

func (organizationQuery) AddResourceOrganizationLabels

func (q organizationQuery) AddResourceOrganizationLabels(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationLabel) error

AddResourceOrganizationLabels adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.ResourceOrganizationLabels. Sets related.R.Resource appropriately.

func (organizationQuery) AddServicePlanVisibilities

func (q organizationQuery) AddServicePlanVisibilities(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServicePlanVisibility) error

AddServicePlanVisibilities adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.ServicePlanVisibilities. Sets related.R.Organization appropriately.

func (organizationQuery) AddSpaceQuotaDefinitions

func (q organizationQuery) AddSpaceQuotaDefinitions(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpaceQuotaDefinition) error

AddSpaceQuotaDefinitions adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.SpaceQuotaDefinitions. Sets related.R.Organization appropriately.

func (organizationQuery) AddSpaces

func (q organizationQuery) AddSpaces(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Space) error

AddSpaces adds the given related objects to the existing relationships of the organization\, optionally inserting them as new records. Appends related to o.R.Spaces. Sets related.R.Organization appropriately.

func (organizationQuery) All

func (q organizationQuery) All(ctx context.Context, exec boil.ContextExecutor) (OrganizationSlice, error)

All returns all Organization records from the query.

func (organizationQuery) Count

func (q organizationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Organization records in the query.

func (organizationQuery) Delete

func (q organizationQuery) Delete(o *Organization, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Organization record with an executor. Delete will match against the primary key column to find the record to delete.

func (organizationQuery) DeleteAll

func (q organizationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (organizationQuery) DeleteAllSlice

func (q organizationQuery) DeleteAllSlice(o OrganizationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (organizationQuery) Exists

func (q organizationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (organizationQuery) Insert

func (q organizationQuery) Insert(o *Organization, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (organizationQuery) IsolationSegments

func (q organizationQuery) IsolationSegments(o *Organization, mods ...qm.QueryMod) isolationSegmentQuery

IsolationSegments retrieves all the isolation_segment's IsolationSegments with an executor.

func (organizationQuery) One

func (q organizationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Organization, error)

One returns a single organization record from the query.

func (organizationQuery) OrganizationsAuditors

func (q organizationQuery) OrganizationsAuditors(o *Organization, mods ...qm.QueryMod) organizationsAuditorQuery

OrganizationsAuditors retrieves all the organizations_auditor's OrganizationsAuditors with an executor.

func (organizationQuery) OrganizationsBillingManagers

func (q organizationQuery) OrganizationsBillingManagers(o *Organization, mods ...qm.QueryMod) organizationsBillingManagerQuery

OrganizationsBillingManagers retrieves all the organizations_billing_manager's OrganizationsBillingManagers with an executor.

func (organizationQuery) OrganizationsManagers

func (q organizationQuery) OrganizationsManagers(o *Organization, mods ...qm.QueryMod) organizationsManagerQuery

OrganizationsManagers retrieves all the organizations_manager's OrganizationsManagers with an executor.

func (organizationQuery) OrganizationsPrivateDomains

func (q organizationQuery) OrganizationsPrivateDomains(o *Organization, mods ...qm.QueryMod) organizationsPrivateDomainQuery

OrganizationsPrivateDomains retrieves all the organizations_private_domain's OrganizationsPrivateDomains with an executor.

func (organizationQuery) OrganizationsUsers

func (q organizationQuery) OrganizationsUsers(o *Organization, mods ...qm.QueryMod) organizationsUserQuery

OrganizationsUsers retrieves all the organizations_user's OrganizationsUsers with an executor.

func (organizationQuery) OwningOrganizationDomains

func (q organizationQuery) OwningOrganizationDomains(o *Organization, mods ...qm.QueryMod) domainQuery

OwningOrganizationDomains retrieves all the domain's Domains with an executor via owning_organization_id column.

func (organizationQuery) QuotaDefinition

func (q organizationQuery) QuotaDefinition(o *Organization, mods ...qm.QueryMod) quotaDefinitionQuery

QuotaDefinition pointed to by the foreign key.

func (organizationQuery) Reload

func (q organizationQuery) Reload(o *Organization, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (organizationQuery) ReloadAll

func (q organizationQuery) ReloadAll(o *OrganizationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (organizationQuery) RemoveIsolationSegments

func (q organizationQuery) RemoveIsolationSegments(o *Organization, ctx context.Context, exec boil.ContextExecutor, related ...*IsolationSegment) error

RemoveIsolationSegments relationships from objects passed in. Removes related items from R.IsolationSegments (uses pointer comparison\, removal does not keep order) Sets related.R.Organizations.

func (organizationQuery) RemoveOwningOrganizationDomains

func (q organizationQuery) RemoveOwningOrganizationDomains(o *Organization, ctx context.Context, exec boil.ContextExecutor, related ...*Domain) error

RemoveOwningOrganizationDomains relationships from objects passed in. Removes related items from R.OwningOrganizationDomains (uses pointer comparison\, removal does not keep order) Sets related.R.OwningOrganization.

func (organizationQuery) RemoveResourceOrganizationAnnotations

func (q organizationQuery) RemoveResourceOrganizationAnnotations(o *Organization, ctx context.Context, exec boil.ContextExecutor, related ...*OrganizationAnnotation) error

RemoveResourceOrganizationAnnotations relationships from objects passed in. Removes related items from R.ResourceOrganizationAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (organizationQuery) RemoveResourceOrganizationLabels

func (q organizationQuery) RemoveResourceOrganizationLabels(o *Organization, ctx context.Context, exec boil.ContextExecutor, related ...*OrganizationLabel) error

RemoveResourceOrganizationLabels relationships from objects passed in. Removes related items from R.ResourceOrganizationLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (organizationQuery) ResourceOrganizationAnnotations

func (q organizationQuery) ResourceOrganizationAnnotations(o *Organization, mods ...qm.QueryMod) organizationAnnotationQuery

ResourceOrganizationAnnotations retrieves all the organization_annotation's OrganizationAnnotations with an executor via resource_guid column.

func (organizationQuery) ResourceOrganizationLabels

func (q organizationQuery) ResourceOrganizationLabels(o *Organization, mods ...qm.QueryMod) organizationLabelQuery

ResourceOrganizationLabels retrieves all the organization_label's OrganizationLabels with an executor via resource_guid column.

func (organizationQuery) ServicePlanVisibilities

func (q organizationQuery) ServicePlanVisibilities(o *Organization, mods ...qm.QueryMod) servicePlanVisibilityQuery

ServicePlanVisibilities retrieves all the service_plan_visibility's ServicePlanVisibilities with an executor.

func (organizationQuery) SetIsolationSegments

func (q organizationQuery) SetIsolationSegments(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*IsolationSegment) error

SetIsolationSegments removes all previously related items of the organization replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Organizations's IsolationSegments accordingly. Replaces o.R.IsolationSegments with related. Sets related.R.Organizations's IsolationSegments accordingly.

func (organizationQuery) SetOwningOrganizationDomains

func (q organizationQuery) SetOwningOrganizationDomains(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Domain) error

SetOwningOrganizationDomains removes all previously related items of the organization replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.OwningOrganization's OwningOrganizationDomains accordingly. Replaces o.R.OwningOrganizationDomains with related. Sets related.R.OwningOrganization's OwningOrganizationDomains accordingly.

func (organizationQuery) SetQuotaDefinition

func (q organizationQuery) SetQuotaDefinition(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related *QuotaDefinition) error

SetQuotaDefinition of the organization to the related item. Sets o.R.QuotaDefinition to related. Adds o to related.R.Organizations.

func (organizationQuery) SetResourceOrganizationAnnotations

func (q organizationQuery) SetResourceOrganizationAnnotations(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationAnnotation) error

SetResourceOrganizationAnnotations removes all previously related items of the organization replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceOrganizationAnnotations accordingly. Replaces o.R.ResourceOrganizationAnnotations with related. Sets related.R.Resource's ResourceOrganizationAnnotations accordingly.

func (organizationQuery) SetResourceOrganizationLabels

func (q organizationQuery) SetResourceOrganizationLabels(o *Organization, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationLabel) error

SetResourceOrganizationLabels removes all previously related items of the organization replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceOrganizationLabels accordingly. Replaces o.R.ResourceOrganizationLabels with related. Sets related.R.Resource's ResourceOrganizationLabels accordingly.

func (organizationQuery) SpaceQuotaDefinitions

func (q organizationQuery) SpaceQuotaDefinitions(o *Organization, mods ...qm.QueryMod) spaceQuotaDefinitionQuery

SpaceQuotaDefinitions retrieves all the space_quota_definition's SpaceQuotaDefinitions with an executor.

func (organizationQuery) Spaces

func (q organizationQuery) Spaces(o *Organization, mods ...qm.QueryMod) spaceQuery

Spaces retrieves all the space's Spaces with an executor.

func (organizationQuery) Update

func (q organizationQuery) Update(o *Organization, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Organization. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (organizationQuery) UpdateAll

func (q organizationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (organizationQuery) UpdateAllSlice

func (q organizationQuery) UpdateAllSlice(o OrganizationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (organizationQuery) Upsert

func (q organizationQuery) Upsert(o *Organization, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type organizationR

organizationR is where relationships are stored.

type organizationR struct {
    QuotaDefinition                 *QuotaDefinition                 `boil:"QuotaDefinition" json:"QuotaDefinition" toml:"QuotaDefinition" yaml:"QuotaDefinition"`
    OwningOrganizationDomains       DomainSlice                      `boil:"OwningOrganizationDomains" json:"OwningOrganizationDomains" toml:"OwningOrganizationDomains" yaml:"OwningOrganizationDomains"`
    ResourceOrganizationAnnotations OrganizationAnnotationSlice      `boil:"ResourceOrganizationAnnotations" json:"ResourceOrganizationAnnotations" toml:"ResourceOrganizationAnnotations" yaml:"ResourceOrganizationAnnotations"`
    ResourceOrganizationLabels      OrganizationLabelSlice           `boil:"ResourceOrganizationLabels" json:"ResourceOrganizationLabels" toml:"ResourceOrganizationLabels" yaml:"ResourceOrganizationLabels"`
    OrganizationsAuditors           OrganizationsAuditorSlice        `boil:"OrganizationsAuditors" json:"OrganizationsAuditors" toml:"OrganizationsAuditors" yaml:"OrganizationsAuditors"`
    OrganizationsBillingManagers    OrganizationsBillingManagerSlice `boil:"OrganizationsBillingManagers" json:"OrganizationsBillingManagers" toml:"OrganizationsBillingManagers" yaml:"OrganizationsBillingManagers"`
    IsolationSegments               IsolationSegmentSlice            `boil:"IsolationSegments" json:"IsolationSegments" toml:"IsolationSegments" yaml:"IsolationSegments"`
    OrganizationsManagers           OrganizationsManagerSlice        `boil:"OrganizationsManagers" json:"OrganizationsManagers" toml:"OrganizationsManagers" yaml:"OrganizationsManagers"`
    OrganizationsPrivateDomains     OrganizationsPrivateDomainSlice  `boil:"OrganizationsPrivateDomains" json:"OrganizationsPrivateDomains" toml:"OrganizationsPrivateDomains" yaml:"OrganizationsPrivateDomains"`
    OrganizationsUsers              OrganizationsUserSlice           `boil:"OrganizationsUsers" json:"OrganizationsUsers" toml:"OrganizationsUsers" yaml:"OrganizationsUsers"`
    ServicePlanVisibilities         ServicePlanVisibilitySlice       `boil:"ServicePlanVisibilities" json:"ServicePlanVisibilities" toml:"ServicePlanVisibilities" yaml:"ServicePlanVisibilities"`
    SpaceQuotaDefinitions           SpaceQuotaDefinitionSlice        `boil:"SpaceQuotaDefinitions" json:"SpaceQuotaDefinitions" toml:"SpaceQuotaDefinitions" yaml:"SpaceQuotaDefinitions"`
    Spaces                          SpaceSlice                       `boil:"Spaces" json:"Spaces" toml:"Spaces" yaml:"Spaces"`
}

func (*organizationR) NewStruct

func (*organizationR) NewStruct() *organizationR

NewStruct creates a new relationship struct

type organizationsAuditorL

organizationsAuditorL is where Load methods for each relationship are stored.

type organizationsAuditorL struct{}

func (organizationsAuditorL) LoadOrganization

func (organizationsAuditorL) LoadOrganization(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationsAuditor interface{}, mods queries.Applicator) error

LoadOrganization allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (organizationsAuditorL) LoadUser

func (organizationsAuditorL) LoadUser(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationsAuditor interface{}, mods queries.Applicator) error

LoadUser allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type organizationsAuditorQuery

type organizationsAuditorQuery struct {
    *queries.Query
}

func OrganizationsAuditors

func OrganizationsAuditors(mods ...qm.QueryMod) organizationsAuditorQuery

OrganizationsAuditors retrieves all the records using an executor.

func (organizationsAuditorQuery) All

func (q organizationsAuditorQuery) All(ctx context.Context, exec boil.ContextExecutor) (OrganizationsAuditorSlice, error)

All returns all OrganizationsAuditor records from the query.

func (organizationsAuditorQuery) Count

func (q organizationsAuditorQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all OrganizationsAuditor records in the query.

func (organizationsAuditorQuery) Delete

func (q organizationsAuditorQuery) Delete(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single OrganizationsAuditor record with an executor. Delete will match against the primary key column to find the record to delete.

func (organizationsAuditorQuery) DeleteAll

func (q organizationsAuditorQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (organizationsAuditorQuery) DeleteAllSlice

func (q organizationsAuditorQuery) DeleteAllSlice(o OrganizationsAuditorSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (organizationsAuditorQuery) Exists

func (q organizationsAuditorQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (organizationsAuditorQuery) Insert

func (q organizationsAuditorQuery) Insert(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (organizationsAuditorQuery) One

func (q organizationsAuditorQuery) One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationsAuditor, error)

One returns a single organizationsAuditor record from the query.

func (organizationsAuditorQuery) Organization

func (q organizationsAuditorQuery) Organization(o *OrganizationsAuditor, mods ...qm.QueryMod) organizationQuery

Organization pointed to by the foreign key.

func (organizationsAuditorQuery) Reload

func (q organizationsAuditorQuery) Reload(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (organizationsAuditorQuery) ReloadAll

func (q organizationsAuditorQuery) ReloadAll(o *OrganizationsAuditorSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (organizationsAuditorQuery) SetOrganization

func (q organizationsAuditorQuery) SetOrganization(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Organization) error

SetOrganization of the organizationsAuditor to the related item. Sets o.R.Organization to related. Adds o to related.R.OrganizationsAuditors.

func (organizationsAuditorQuery) SetUser

func (q organizationsAuditorQuery) SetUser(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor, insert bool, related *User) error

SetUser of the organizationsAuditor to the related item. Sets o.R.User to related. Adds o to related.R.OrganizationsAuditors.

func (organizationsAuditorQuery) Update

func (q organizationsAuditorQuery) Update(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the OrganizationsAuditor. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (organizationsAuditorQuery) UpdateAll

func (q organizationsAuditorQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (organizationsAuditorQuery) UpdateAllSlice

func (q organizationsAuditorQuery) UpdateAllSlice(o OrganizationsAuditorSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (organizationsAuditorQuery) Upsert

func (q organizationsAuditorQuery) Upsert(o *OrganizationsAuditor, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

func (organizationsAuditorQuery) User

func (q organizationsAuditorQuery) User(o *OrganizationsAuditor, mods ...qm.QueryMod) userQuery

User pointed to by the foreign key.

type organizationsAuditorR

organizationsAuditorR is where relationships are stored.

type organizationsAuditorR struct {
    Organization *Organization `boil:"Organization" json:"Organization" toml:"Organization" yaml:"Organization"`
    User         *User         `boil:"User" json:"User" toml:"User" yaml:"User"`
}

func (*organizationsAuditorR) NewStruct

func (*organizationsAuditorR) NewStruct() *organizationsAuditorR

NewStruct creates a new relationship struct

type organizationsBillingManagerL

organizationsBillingManagerL is where Load methods for each relationship are stored.

type organizationsBillingManagerL struct{}

func (organizationsBillingManagerL) LoadOrganization

func (organizationsBillingManagerL) LoadOrganization(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationsBillingManager interface{}, mods queries.Applicator) error

LoadOrganization allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (organizationsBillingManagerL) LoadUser

func (organizationsBillingManagerL) LoadUser(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationsBillingManager interface{}, mods queries.Applicator) error

LoadUser allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type organizationsBillingManagerQuery

type organizationsBillingManagerQuery struct {
    *queries.Query
}

func OrganizationsBillingManagers

func OrganizationsBillingManagers(mods ...qm.QueryMod) organizationsBillingManagerQuery

OrganizationsBillingManagers retrieves all the records using an executor.

func (organizationsBillingManagerQuery) All

func (q organizationsBillingManagerQuery) All(ctx context.Context, exec boil.ContextExecutor) (OrganizationsBillingManagerSlice, error)

All returns all OrganizationsBillingManager records from the query.

func (organizationsBillingManagerQuery) Count

func (q organizationsBillingManagerQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all OrganizationsBillingManager records in the query.

func (organizationsBillingManagerQuery) Delete

func (q organizationsBillingManagerQuery) Delete(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single OrganizationsBillingManager record with an executor. Delete will match against the primary key column to find the record to delete.

func (organizationsBillingManagerQuery) DeleteAll

func (q organizationsBillingManagerQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (organizationsBillingManagerQuery) DeleteAllSlice

func (q organizationsBillingManagerQuery) DeleteAllSlice(o OrganizationsBillingManagerSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (organizationsBillingManagerQuery) Exists

func (q organizationsBillingManagerQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (organizationsBillingManagerQuery) Insert

func (q organizationsBillingManagerQuery) Insert(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (organizationsBillingManagerQuery) One

func (q organizationsBillingManagerQuery) One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationsBillingManager, error)

One returns a single organizationsBillingManager record from the query.

func (organizationsBillingManagerQuery) Organization

func (q organizationsBillingManagerQuery) Organization(o *OrganizationsBillingManager, mods ...qm.QueryMod) organizationQuery

Organization pointed to by the foreign key.

func (organizationsBillingManagerQuery) Reload

func (q organizationsBillingManagerQuery) Reload(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (organizationsBillingManagerQuery) ReloadAll

func (q organizationsBillingManagerQuery) ReloadAll(o *OrganizationsBillingManagerSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (organizationsBillingManagerQuery) SetOrganization

func (q organizationsBillingManagerQuery) SetOrganization(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Organization) error

SetOrganization of the organizationsBillingManager to the related item. Sets o.R.Organization to related. Adds o to related.R.OrganizationsBillingManagers.

func (organizationsBillingManagerQuery) SetUser

func (q organizationsBillingManagerQuery) SetUser(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor, insert bool, related *User) error

SetUser of the organizationsBillingManager to the related item. Sets o.R.User to related. Adds o to related.R.OrganizationsBillingManagers.

func (organizationsBillingManagerQuery) Update

func (q organizationsBillingManagerQuery) Update(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the OrganizationsBillingManager. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (organizationsBillingManagerQuery) UpdateAll

func (q organizationsBillingManagerQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (organizationsBillingManagerQuery) UpdateAllSlice

func (q organizationsBillingManagerQuery) UpdateAllSlice(o OrganizationsBillingManagerSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (organizationsBillingManagerQuery) Upsert

func (q organizationsBillingManagerQuery) Upsert(o *OrganizationsBillingManager, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

func (organizationsBillingManagerQuery) User

func (q organizationsBillingManagerQuery) User(o *OrganizationsBillingManager, mods ...qm.QueryMod) userQuery

User pointed to by the foreign key.

type organizationsBillingManagerR

organizationsBillingManagerR is where relationships are stored.

type organizationsBillingManagerR struct {
    Organization *Organization `boil:"Organization" json:"Organization" toml:"Organization" yaml:"Organization"`
    User         *User         `boil:"User" json:"User" toml:"User" yaml:"User"`
}

func (*organizationsBillingManagerR) NewStruct

func (*organizationsBillingManagerR) NewStruct() *organizationsBillingManagerR

NewStruct creates a new relationship struct

type organizationsManagerL

organizationsManagerL is where Load methods for each relationship are stored.

type organizationsManagerL struct{}

func (organizationsManagerL) LoadOrganization

func (organizationsManagerL) LoadOrganization(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationsManager interface{}, mods queries.Applicator) error

LoadOrganization allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (organizationsManagerL) LoadUser

func (organizationsManagerL) LoadUser(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationsManager interface{}, mods queries.Applicator) error

LoadUser allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type organizationsManagerQuery

type organizationsManagerQuery struct {
    *queries.Query
}

func OrganizationsManagers

func OrganizationsManagers(mods ...qm.QueryMod) organizationsManagerQuery

OrganizationsManagers retrieves all the records using an executor.

func (organizationsManagerQuery) All

func (q organizationsManagerQuery) All(ctx context.Context, exec boil.ContextExecutor) (OrganizationsManagerSlice, error)

All returns all OrganizationsManager records from the query.

func (organizationsManagerQuery) Count

func (q organizationsManagerQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all OrganizationsManager records in the query.

func (organizationsManagerQuery) Delete

func (q organizationsManagerQuery) Delete(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single OrganizationsManager record with an executor. Delete will match against the primary key column to find the record to delete.

func (organizationsManagerQuery) DeleteAll

func (q organizationsManagerQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (organizationsManagerQuery) DeleteAllSlice

func (q organizationsManagerQuery) DeleteAllSlice(o OrganizationsManagerSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (organizationsManagerQuery) Exists

func (q organizationsManagerQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (organizationsManagerQuery) Insert

func (q organizationsManagerQuery) Insert(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (organizationsManagerQuery) One

func (q organizationsManagerQuery) One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationsManager, error)

One returns a single organizationsManager record from the query.

func (organizationsManagerQuery) Organization

func (q organizationsManagerQuery) Organization(o *OrganizationsManager, mods ...qm.QueryMod) organizationQuery

Organization pointed to by the foreign key.

func (organizationsManagerQuery) Reload

func (q organizationsManagerQuery) Reload(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (organizationsManagerQuery) ReloadAll

func (q organizationsManagerQuery) ReloadAll(o *OrganizationsManagerSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (organizationsManagerQuery) SetOrganization

func (q organizationsManagerQuery) SetOrganization(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Organization) error

SetOrganization of the organizationsManager to the related item. Sets o.R.Organization to related. Adds o to related.R.OrganizationsManagers.

func (organizationsManagerQuery) SetUser

func (q organizationsManagerQuery) SetUser(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor, insert bool, related *User) error

SetUser of the organizationsManager to the related item. Sets o.R.User to related. Adds o to related.R.OrganizationsManagers.

func (organizationsManagerQuery) Update

func (q organizationsManagerQuery) Update(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the OrganizationsManager. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (organizationsManagerQuery) UpdateAll

func (q organizationsManagerQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (organizationsManagerQuery) UpdateAllSlice

func (q organizationsManagerQuery) UpdateAllSlice(o OrganizationsManagerSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (organizationsManagerQuery) Upsert

func (q organizationsManagerQuery) Upsert(o *OrganizationsManager, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

func (organizationsManagerQuery) User

func (q organizationsManagerQuery) User(o *OrganizationsManager, mods ...qm.QueryMod) userQuery

User pointed to by the foreign key.

type organizationsManagerR

organizationsManagerR is where relationships are stored.

type organizationsManagerR struct {
    Organization *Organization `boil:"Organization" json:"Organization" toml:"Organization" yaml:"Organization"`
    User         *User         `boil:"User" json:"User" toml:"User" yaml:"User"`
}

func (*organizationsManagerR) NewStruct

func (*organizationsManagerR) NewStruct() *organizationsManagerR

NewStruct creates a new relationship struct

type organizationsPrivateDomainL

organizationsPrivateDomainL is where Load methods for each relationship are stored.

type organizationsPrivateDomainL struct{}

func (organizationsPrivateDomainL) LoadOrganization

func (organizationsPrivateDomainL) LoadOrganization(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationsPrivateDomain interface{}, mods queries.Applicator) error

LoadOrganization allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (organizationsPrivateDomainL) LoadPrivateDomain

func (organizationsPrivateDomainL) LoadPrivateDomain(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationsPrivateDomain interface{}, mods queries.Applicator) error

LoadPrivateDomain allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type organizationsPrivateDomainQuery

type organizationsPrivateDomainQuery struct {
    *queries.Query
}

func OrganizationsPrivateDomains

func OrganizationsPrivateDomains(mods ...qm.QueryMod) organizationsPrivateDomainQuery

OrganizationsPrivateDomains retrieves all the records using an executor.

func (organizationsPrivateDomainQuery) All

func (q organizationsPrivateDomainQuery) All(ctx context.Context, exec boil.ContextExecutor) (OrganizationsPrivateDomainSlice, error)

All returns all OrganizationsPrivateDomain records from the query.

func (organizationsPrivateDomainQuery) Count

func (q organizationsPrivateDomainQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all OrganizationsPrivateDomain records in the query.

func (organizationsPrivateDomainQuery) Delete

func (q organizationsPrivateDomainQuery) Delete(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single OrganizationsPrivateDomain record with an executor. Delete will match against the primary key column to find the record to delete.

func (organizationsPrivateDomainQuery) DeleteAll

func (q organizationsPrivateDomainQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (organizationsPrivateDomainQuery) DeleteAllSlice

func (q organizationsPrivateDomainQuery) DeleteAllSlice(o OrganizationsPrivateDomainSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (organizationsPrivateDomainQuery) Exists

func (q organizationsPrivateDomainQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (organizationsPrivateDomainQuery) Insert

func (q organizationsPrivateDomainQuery) Insert(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (organizationsPrivateDomainQuery) One

func (q organizationsPrivateDomainQuery) One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationsPrivateDomain, error)

One returns a single organizationsPrivateDomain record from the query.

func (organizationsPrivateDomainQuery) Organization

func (q organizationsPrivateDomainQuery) Organization(o *OrganizationsPrivateDomain, mods ...qm.QueryMod) organizationQuery

Organization pointed to by the foreign key.

func (organizationsPrivateDomainQuery) PrivateDomain

func (q organizationsPrivateDomainQuery) PrivateDomain(o *OrganizationsPrivateDomain, mods ...qm.QueryMod) domainQuery

PrivateDomain pointed to by the foreign key.

func (organizationsPrivateDomainQuery) Reload

func (q organizationsPrivateDomainQuery) Reload(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (organizationsPrivateDomainQuery) ReloadAll

func (q organizationsPrivateDomainQuery) ReloadAll(o *OrganizationsPrivateDomainSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (organizationsPrivateDomainQuery) SetOrganization

func (q organizationsPrivateDomainQuery) SetOrganization(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Organization) error

SetOrganization of the organizationsPrivateDomain to the related item. Sets o.R.Organization to related. Adds o to related.R.OrganizationsPrivateDomains.

func (organizationsPrivateDomainQuery) SetPrivateDomain

func (q organizationsPrivateDomainQuery) SetPrivateDomain(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Domain) error

SetPrivateDomain of the organizationsPrivateDomain to the related item. Sets o.R.PrivateDomain to related. Adds o to related.R.PrivateDomainOrganizationsPrivateDomains.

func (organizationsPrivateDomainQuery) Update

func (q organizationsPrivateDomainQuery) Update(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the OrganizationsPrivateDomain. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (organizationsPrivateDomainQuery) UpdateAll

func (q organizationsPrivateDomainQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (organizationsPrivateDomainQuery) UpdateAllSlice

func (q organizationsPrivateDomainQuery) UpdateAllSlice(o OrganizationsPrivateDomainSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (organizationsPrivateDomainQuery) Upsert

func (q organizationsPrivateDomainQuery) Upsert(o *OrganizationsPrivateDomain, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type organizationsPrivateDomainR

organizationsPrivateDomainR is where relationships are stored.

type organizationsPrivateDomainR struct {
    Organization  *Organization `boil:"Organization" json:"Organization" toml:"Organization" yaml:"Organization"`
    PrivateDomain *Domain       `boil:"PrivateDomain" json:"PrivateDomain" toml:"PrivateDomain" yaml:"PrivateDomain"`
}

func (*organizationsPrivateDomainR) NewStruct

func (*organizationsPrivateDomainR) NewStruct() *organizationsPrivateDomainR

NewStruct creates a new relationship struct

type organizationsUserL

organizationsUserL is where Load methods for each relationship are stored.

type organizationsUserL struct{}

func (organizationsUserL) LoadOrganization

func (organizationsUserL) LoadOrganization(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationsUser interface{}, mods queries.Applicator) error

LoadOrganization allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (organizationsUserL) LoadUser

func (organizationsUserL) LoadUser(ctx context.Context, e boil.ContextExecutor, singular bool, maybeOrganizationsUser interface{}, mods queries.Applicator) error

LoadUser allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type organizationsUserQuery

type organizationsUserQuery struct {
    *queries.Query
}

func OrganizationsUsers

func OrganizationsUsers(mods ...qm.QueryMod) organizationsUserQuery

OrganizationsUsers retrieves all the records using an executor.

func (organizationsUserQuery) All

func (q organizationsUserQuery) All(ctx context.Context, exec boil.ContextExecutor) (OrganizationsUserSlice, error)

All returns all OrganizationsUser records from the query.

func (organizationsUserQuery) Count

func (q organizationsUserQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all OrganizationsUser records in the query.

func (organizationsUserQuery) Delete

func (q organizationsUserQuery) Delete(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single OrganizationsUser record with an executor. Delete will match against the primary key column to find the record to delete.

func (organizationsUserQuery) DeleteAll

func (q organizationsUserQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (organizationsUserQuery) DeleteAllSlice

func (q organizationsUserQuery) DeleteAllSlice(o OrganizationsUserSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (organizationsUserQuery) Exists

func (q organizationsUserQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (organizationsUserQuery) Insert

func (q organizationsUserQuery) Insert(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (organizationsUserQuery) One

func (q organizationsUserQuery) One(ctx context.Context, exec boil.ContextExecutor) (*OrganizationsUser, error)

One returns a single organizationsUser record from the query.

func (organizationsUserQuery) Organization

func (q organizationsUserQuery) Organization(o *OrganizationsUser, mods ...qm.QueryMod) organizationQuery

Organization pointed to by the foreign key.

func (organizationsUserQuery) Reload

func (q organizationsUserQuery) Reload(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (organizationsUserQuery) ReloadAll

func (q organizationsUserQuery) ReloadAll(o *OrganizationsUserSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (organizationsUserQuery) SetOrganization

func (q organizationsUserQuery) SetOrganization(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Organization) error

SetOrganization of the organizationsUser to the related item. Sets o.R.Organization to related. Adds o to related.R.OrganizationsUsers.

func (organizationsUserQuery) SetUser

func (q organizationsUserQuery) SetUser(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor, insert bool, related *User) error

SetUser of the organizationsUser to the related item. Sets o.R.User to related. Adds o to related.R.OrganizationsUsers.

func (organizationsUserQuery) Update

func (q organizationsUserQuery) Update(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the OrganizationsUser. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (organizationsUserQuery) UpdateAll

func (q organizationsUserQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (organizationsUserQuery) UpdateAllSlice

func (q organizationsUserQuery) UpdateAllSlice(o OrganizationsUserSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (organizationsUserQuery) Upsert

func (q organizationsUserQuery) Upsert(o *OrganizationsUser, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

func (organizationsUserQuery) User

func (q organizationsUserQuery) User(o *OrganizationsUser, mods ...qm.QueryMod) userQuery

User pointed to by the foreign key.

type organizationsUserR

organizationsUserR is where relationships are stored.

type organizationsUserR struct {
    Organization *Organization `boil:"Organization" json:"Organization" toml:"Organization" yaml:"Organization"`
    User         *User         `boil:"User" json:"User" toml:"User" yaml:"User"`
}

func (*organizationsUserR) NewStruct

func (*organizationsUserR) NewStruct() *organizationsUserR

NewStruct creates a new relationship struct

type orphanedBlobL

orphanedBlobL is where Load methods for each relationship are stored.

type orphanedBlobL struct{}

type orphanedBlobQuery

type orphanedBlobQuery struct {
    *queries.Query
}

func OrphanedBlobs

func OrphanedBlobs(mods ...qm.QueryMod) orphanedBlobQuery

OrphanedBlobs retrieves all the records using an executor.

func (orphanedBlobQuery) All

func (q orphanedBlobQuery) All(ctx context.Context, exec boil.ContextExecutor) (OrphanedBlobSlice, error)

All returns all OrphanedBlob records from the query.

func (orphanedBlobQuery) Count

func (q orphanedBlobQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all OrphanedBlob records in the query.

func (orphanedBlobQuery) Delete

func (q orphanedBlobQuery) Delete(o *OrphanedBlob, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single OrphanedBlob record with an executor. Delete will match against the primary key column to find the record to delete.

func (orphanedBlobQuery) DeleteAll

func (q orphanedBlobQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (orphanedBlobQuery) DeleteAllSlice

func (q orphanedBlobQuery) DeleteAllSlice(o OrphanedBlobSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (orphanedBlobQuery) Exists

func (q orphanedBlobQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (orphanedBlobQuery) Insert

func (q orphanedBlobQuery) Insert(o *OrphanedBlob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (orphanedBlobQuery) One

func (q orphanedBlobQuery) One(ctx context.Context, exec boil.ContextExecutor) (*OrphanedBlob, error)

One returns a single orphanedBlob record from the query.

func (orphanedBlobQuery) Reload

func (q orphanedBlobQuery) Reload(o *OrphanedBlob, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (orphanedBlobQuery) ReloadAll

func (q orphanedBlobQuery) ReloadAll(o *OrphanedBlobSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (orphanedBlobQuery) Update

func (q orphanedBlobQuery) Update(o *OrphanedBlob, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the OrphanedBlob. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (orphanedBlobQuery) UpdateAll

func (q orphanedBlobQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (orphanedBlobQuery) UpdateAllSlice

func (q orphanedBlobQuery) UpdateAllSlice(o OrphanedBlobSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (orphanedBlobQuery) Upsert

func (q orphanedBlobQuery) Upsert(o *OrphanedBlob, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type orphanedBlobR

orphanedBlobR is where relationships are stored.

type orphanedBlobR struct {
}

func (*orphanedBlobR) NewStruct

func (*orphanedBlobR) NewStruct() *orphanedBlobR

NewStruct creates a new relationship struct

type packageAnnotationL

packageAnnotationL is where Load methods for each relationship are stored.

type packageAnnotationL struct{}

func (packageAnnotationL) LoadResource

func (packageAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybePackageAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type packageAnnotationQuery

type packageAnnotationQuery struct {
    *queries.Query
}

func PackageAnnotations

func PackageAnnotations(mods ...qm.QueryMod) packageAnnotationQuery

PackageAnnotations retrieves all the records using an executor.

func (packageAnnotationQuery) All

func (q packageAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (PackageAnnotationSlice, error)

All returns all PackageAnnotation records from the query.

func (packageAnnotationQuery) Count

func (q packageAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all PackageAnnotation records in the query.

func (packageAnnotationQuery) Delete

func (q packageAnnotationQuery) Delete(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single PackageAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (packageAnnotationQuery) DeleteAll

func (q packageAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (packageAnnotationQuery) DeleteAllSlice

func (q packageAnnotationQuery) DeleteAllSlice(o PackageAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (packageAnnotationQuery) Exists

func (q packageAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (packageAnnotationQuery) Insert

func (q packageAnnotationQuery) Insert(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (packageAnnotationQuery) One

func (q packageAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*PackageAnnotation, error)

One returns a single packageAnnotation record from the query.

func (packageAnnotationQuery) Reload

func (q packageAnnotationQuery) Reload(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (packageAnnotationQuery) ReloadAll

func (q packageAnnotationQuery) ReloadAll(o *PackageAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (packageAnnotationQuery) RemoveResource

func (q packageAnnotationQuery) RemoveResource(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Package) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (packageAnnotationQuery) Resource

func (q packageAnnotationQuery) Resource(o *PackageAnnotation, mods ...qm.QueryMod) packageQuery

Resource pointed to by the foreign key.

func (packageAnnotationQuery) SetResource

func (q packageAnnotationQuery) SetResource(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Package) error

SetResource of the packageAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourcePackageAnnotations.

func (packageAnnotationQuery) Update

func (q packageAnnotationQuery) Update(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the PackageAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (packageAnnotationQuery) UpdateAll

func (q packageAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (packageAnnotationQuery) UpdateAllSlice

func (q packageAnnotationQuery) UpdateAllSlice(o PackageAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (packageAnnotationQuery) Upsert

func (q packageAnnotationQuery) Upsert(o *PackageAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type packageAnnotationR

packageAnnotationR is where relationships are stored.

type packageAnnotationR struct {
    Resource *Package `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*packageAnnotationR) NewStruct

func (*packageAnnotationR) NewStruct() *packageAnnotationR

NewStruct creates a new relationship struct

type packageL

packageL is where Load methods for each relationship are stored.

type packageL struct{}

func (packageL) LoadApp

func (packageL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybePackage interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (packageL) LoadResourcePackageAnnotations

func (packageL) LoadResourcePackageAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybePackage interface{}, mods queries.Applicator) error

LoadResourcePackageAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (packageL) LoadResourcePackageLabels

func (packageL) LoadResourcePackageLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybePackage interface{}, mods queries.Applicator) error

LoadResourcePackageLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type packageLabelL

packageLabelL is where Load methods for each relationship are stored.

type packageLabelL struct{}

func (packageLabelL) LoadResource

func (packageLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybePackageLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type packageLabelQuery

type packageLabelQuery struct {
    *queries.Query
}

func PackageLabels

func PackageLabels(mods ...qm.QueryMod) packageLabelQuery

PackageLabels retrieves all the records using an executor.

func (packageLabelQuery) All

func (q packageLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (PackageLabelSlice, error)

All returns all PackageLabel records from the query.

func (packageLabelQuery) Count

func (q packageLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all PackageLabel records in the query.

func (packageLabelQuery) Delete

func (q packageLabelQuery) Delete(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single PackageLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (packageLabelQuery) DeleteAll

func (q packageLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (packageLabelQuery) DeleteAllSlice

func (q packageLabelQuery) DeleteAllSlice(o PackageLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (packageLabelQuery) Exists

func (q packageLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (packageLabelQuery) Insert

func (q packageLabelQuery) Insert(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (packageLabelQuery) One

func (q packageLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*PackageLabel, error)

One returns a single packageLabel record from the query.

func (packageLabelQuery) Reload

func (q packageLabelQuery) Reload(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (packageLabelQuery) ReloadAll

func (q packageLabelQuery) ReloadAll(o *PackageLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (packageLabelQuery) RemoveResource

func (q packageLabelQuery) RemoveResource(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor, related *Package) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (packageLabelQuery) Resource

func (q packageLabelQuery) Resource(o *PackageLabel, mods ...qm.QueryMod) packageQuery

Resource pointed to by the foreign key.

func (packageLabelQuery) SetResource

func (q packageLabelQuery) SetResource(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Package) error

SetResource of the packageLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourcePackageLabels.

func (packageLabelQuery) Update

func (q packageLabelQuery) Update(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the PackageLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (packageLabelQuery) UpdateAll

func (q packageLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (packageLabelQuery) UpdateAllSlice

func (q packageLabelQuery) UpdateAllSlice(o PackageLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (packageLabelQuery) Upsert

func (q packageLabelQuery) Upsert(o *PackageLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type packageLabelR

packageLabelR is where relationships are stored.

type packageLabelR struct {
    Resource *Package `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*packageLabelR) NewStruct

func (*packageLabelR) NewStruct() *packageLabelR

NewStruct creates a new relationship struct

type packageQuery

type packageQuery struct {
    *queries.Query
}

func Packages

func Packages(mods ...qm.QueryMod) packageQuery

Packages retrieves all the records using an executor.

func (packageQuery) AddResourcePackageAnnotations

func (q packageQuery) AddResourcePackageAnnotations(o *Package, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*PackageAnnotation) error

AddResourcePackageAnnotations adds the given related objects to the existing relationships of the package\, optionally inserting them as new records. Appends related to o.R.ResourcePackageAnnotations. Sets related.R.Resource appropriately.

func (packageQuery) AddResourcePackageLabels

func (q packageQuery) AddResourcePackageLabels(o *Package, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*PackageLabel) error

AddResourcePackageLabels adds the given related objects to the existing relationships of the package\, optionally inserting them as new records. Appends related to o.R.ResourcePackageLabels. Sets related.R.Resource appropriately.

func (packageQuery) All

func (q packageQuery) All(ctx context.Context, exec boil.ContextExecutor) (PackageSlice, error)

All returns all Package records from the query.

func (packageQuery) App

func (q packageQuery) App(o *Package, mods ...qm.QueryMod) appQuery

App pointed to by the foreign key.

func (packageQuery) Count

func (q packageQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Package records in the query.

func (packageQuery) Delete

func (q packageQuery) Delete(o *Package, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Package record with an executor. Delete will match against the primary key column to find the record to delete.

func (packageQuery) DeleteAll

func (q packageQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (packageQuery) DeleteAllSlice

func (q packageQuery) DeleteAllSlice(o PackageSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (packageQuery) Exists

func (q packageQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (packageQuery) Insert

func (q packageQuery) Insert(o *Package, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (packageQuery) One

func (q packageQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Package, error)

One returns a single package record from the query.

func (packageQuery) Reload

func (q packageQuery) Reload(o *Package, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (packageQuery) ReloadAll

func (q packageQuery) ReloadAll(o *PackageSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (packageQuery) RemoveApp

func (q packageQuery) RemoveApp(o *Package, ctx context.Context, exec boil.ContextExecutor, related *App) error

RemoveApp relationship. Sets o.R.App to nil. Removes o from all passed in related items' relationships struct (Optional).

func (packageQuery) RemoveResourcePackageAnnotations

func (q packageQuery) RemoveResourcePackageAnnotations(o *Package, ctx context.Context, exec boil.ContextExecutor, related ...*PackageAnnotation) error

RemoveResourcePackageAnnotations relationships from objects passed in. Removes related items from R.ResourcePackageAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (packageQuery) RemoveResourcePackageLabels

func (q packageQuery) RemoveResourcePackageLabels(o *Package, ctx context.Context, exec boil.ContextExecutor, related ...*PackageLabel) error

RemoveResourcePackageLabels relationships from objects passed in. Removes related items from R.ResourcePackageLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (packageQuery) ResourcePackageAnnotations

func (q packageQuery) ResourcePackageAnnotations(o *Package, mods ...qm.QueryMod) packageAnnotationQuery

ResourcePackageAnnotations retrieves all the package_annotation's PackageAnnotations with an executor via resource_guid column.

func (packageQuery) ResourcePackageLabels

func (q packageQuery) ResourcePackageLabels(o *Package, mods ...qm.QueryMod) packageLabelQuery

ResourcePackageLabels retrieves all the package_label's PackageLabels with an executor via resource_guid column.

func (packageQuery) SetApp

func (q packageQuery) SetApp(o *Package, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetApp of the package to the related item. Sets o.R.App to related. Adds o to related.R.Packages.

func (packageQuery) SetResourcePackageAnnotations

func (q packageQuery) SetResourcePackageAnnotations(o *Package, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*PackageAnnotation) error

SetResourcePackageAnnotations removes all previously related items of the package replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourcePackageAnnotations accordingly. Replaces o.R.ResourcePackageAnnotations with related. Sets related.R.Resource's ResourcePackageAnnotations accordingly.

func (packageQuery) SetResourcePackageLabels

func (q packageQuery) SetResourcePackageLabels(o *Package, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*PackageLabel) error

SetResourcePackageLabels removes all previously related items of the package replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourcePackageLabels accordingly. Replaces o.R.ResourcePackageLabels with related. Sets related.R.Resource's ResourcePackageLabels accordingly.

func (packageQuery) Update

func (q packageQuery) Update(o *Package, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Package. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (packageQuery) UpdateAll

func (q packageQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (packageQuery) UpdateAllSlice

func (q packageQuery) UpdateAllSlice(o PackageSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (packageQuery) Upsert

func (q packageQuery) Upsert(o *Package, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type packageR

packageR is where relationships are stored.

type packageR struct {
    App                        *App                   `boil:"App" json:"App" toml:"App" yaml:"App"`
    ResourcePackageAnnotations PackageAnnotationSlice `boil:"ResourcePackageAnnotations" json:"ResourcePackageAnnotations" toml:"ResourcePackageAnnotations" yaml:"ResourcePackageAnnotations"`
    ResourcePackageLabels      PackageLabelSlice      `boil:"ResourcePackageLabels" json:"ResourcePackageLabels" toml:"ResourcePackageLabels" yaml:"ResourcePackageLabels"`
}

func (*packageR) NewStruct

func (*packageR) NewStruct() *packageR

NewStruct creates a new relationship struct

type processAnnotationL

processAnnotationL is where Load methods for each relationship are stored.

type processAnnotationL struct{}

func (processAnnotationL) LoadResource

func (processAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeProcessAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type processAnnotationQuery

type processAnnotationQuery struct {
    *queries.Query
}

func ProcessAnnotations

func ProcessAnnotations(mods ...qm.QueryMod) processAnnotationQuery

ProcessAnnotations retrieves all the records using an executor.

func (processAnnotationQuery) All

func (q processAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (ProcessAnnotationSlice, error)

All returns all ProcessAnnotation records from the query.

func (processAnnotationQuery) Count

func (q processAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ProcessAnnotation records in the query.

func (processAnnotationQuery) Delete

func (q processAnnotationQuery) Delete(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ProcessAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (processAnnotationQuery) DeleteAll

func (q processAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (processAnnotationQuery) DeleteAllSlice

func (q processAnnotationQuery) DeleteAllSlice(o ProcessAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (processAnnotationQuery) Exists

func (q processAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (processAnnotationQuery) Insert

func (q processAnnotationQuery) Insert(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (processAnnotationQuery) One

func (q processAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ProcessAnnotation, error)

One returns a single processAnnotation record from the query.

func (processAnnotationQuery) Reload

func (q processAnnotationQuery) Reload(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (processAnnotationQuery) ReloadAll

func (q processAnnotationQuery) ReloadAll(o *ProcessAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (processAnnotationQuery) RemoveResource

func (q processAnnotationQuery) RemoveResource(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Process) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (processAnnotationQuery) Resource

func (q processAnnotationQuery) Resource(o *ProcessAnnotation, mods ...qm.QueryMod) processQuery

Resource pointed to by the foreign key.

func (processAnnotationQuery) SetResource

func (q processAnnotationQuery) SetResource(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Process) error

SetResource of the processAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceProcessAnnotations.

func (processAnnotationQuery) Update

func (q processAnnotationQuery) Update(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ProcessAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (processAnnotationQuery) UpdateAll

func (q processAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (processAnnotationQuery) UpdateAllSlice

func (q processAnnotationQuery) UpdateAllSlice(o ProcessAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (processAnnotationQuery) Upsert

func (q processAnnotationQuery) Upsert(o *ProcessAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type processAnnotationR

processAnnotationR is where relationships are stored.

type processAnnotationR struct {
    Resource *Process `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*processAnnotationR) NewStruct

func (*processAnnotationR) NewStruct() *processAnnotationR

NewStruct creates a new relationship struct

type processL

processL is where Load methods for each relationship are stored.

type processL struct{}

func (processL) LoadApp

func (processL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybeProcess interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (processL) LoadAppAppEvents

func (processL) LoadAppAppEvents(ctx context.Context, e boil.ContextExecutor, singular bool, maybeProcess interface{}, mods queries.Applicator) error

LoadAppAppEvents allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (processL) LoadResourceProcessAnnotations

func (processL) LoadResourceProcessAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeProcess interface{}, mods queries.Applicator) error

LoadResourceProcessAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (processL) LoadResourceProcessLabels

func (processL) LoadResourceProcessLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeProcess interface{}, mods queries.Applicator) error

LoadResourceProcessLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type processLabelL

processLabelL is where Load methods for each relationship are stored.

type processLabelL struct{}

func (processLabelL) LoadResource

func (processLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeProcessLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type processLabelQuery

type processLabelQuery struct {
    *queries.Query
}

func ProcessLabels

func ProcessLabels(mods ...qm.QueryMod) processLabelQuery

ProcessLabels retrieves all the records using an executor.

func (processLabelQuery) All

func (q processLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (ProcessLabelSlice, error)

All returns all ProcessLabel records from the query.

func (processLabelQuery) Count

func (q processLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ProcessLabel records in the query.

func (processLabelQuery) Delete

func (q processLabelQuery) Delete(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ProcessLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (processLabelQuery) DeleteAll

func (q processLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (processLabelQuery) DeleteAllSlice

func (q processLabelQuery) DeleteAllSlice(o ProcessLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (processLabelQuery) Exists

func (q processLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (processLabelQuery) Insert

func (q processLabelQuery) Insert(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (processLabelQuery) One

func (q processLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ProcessLabel, error)

One returns a single processLabel record from the query.

func (processLabelQuery) Reload

func (q processLabelQuery) Reload(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (processLabelQuery) ReloadAll

func (q processLabelQuery) ReloadAll(o *ProcessLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (processLabelQuery) RemoveResource

func (q processLabelQuery) RemoveResource(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor, related *Process) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (processLabelQuery) Resource

func (q processLabelQuery) Resource(o *ProcessLabel, mods ...qm.QueryMod) processQuery

Resource pointed to by the foreign key.

func (processLabelQuery) SetResource

func (q processLabelQuery) SetResource(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Process) error

SetResource of the processLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceProcessLabels.

func (processLabelQuery) Update

func (q processLabelQuery) Update(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ProcessLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (processLabelQuery) UpdateAll

func (q processLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (processLabelQuery) UpdateAllSlice

func (q processLabelQuery) UpdateAllSlice(o ProcessLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (processLabelQuery) Upsert

func (q processLabelQuery) Upsert(o *ProcessLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type processLabelR

processLabelR is where relationships are stored.

type processLabelR struct {
    Resource *Process `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*processLabelR) NewStruct

func (*processLabelR) NewStruct() *processLabelR

NewStruct creates a new relationship struct

type processQuery

type processQuery struct {
    *queries.Query
}

func Processes

func Processes(mods ...qm.QueryMod) processQuery

Processes retrieves all the records using an executor.

func (processQuery) AddAppAppEvents

func (q processQuery) AddAppAppEvents(o *Process, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*AppEvent) error

AddAppAppEvents adds the given related objects to the existing relationships of the process\, optionally inserting them as new records. Appends related to o.R.AppAppEvents. Sets related.R.App appropriately.

func (processQuery) AddResourceProcessAnnotations

func (q processQuery) AddResourceProcessAnnotations(o *Process, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ProcessAnnotation) error

AddResourceProcessAnnotations adds the given related objects to the existing relationships of the process\, optionally inserting them as new records. Appends related to o.R.ResourceProcessAnnotations. Sets related.R.Resource appropriately.

func (processQuery) AddResourceProcessLabels

func (q processQuery) AddResourceProcessLabels(o *Process, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ProcessLabel) error

AddResourceProcessLabels adds the given related objects to the existing relationships of the process\, optionally inserting them as new records. Appends related to o.R.ResourceProcessLabels. Sets related.R.Resource appropriately.

func (processQuery) All

func (q processQuery) All(ctx context.Context, exec boil.ContextExecutor) (ProcessSlice, error)

All returns all Process records from the query.

func (processQuery) App

func (q processQuery) App(o *Process, mods ...qm.QueryMod) appQuery

App pointed to by the foreign key.

func (processQuery) AppAppEvents

func (q processQuery) AppAppEvents(o *Process, mods ...qm.QueryMod) appEventQuery

AppAppEvents retrieves all the app_event's AppEvents with an executor via app_id column.

func (processQuery) Count

func (q processQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Process records in the query.

func (processQuery) Delete

func (q processQuery) Delete(o *Process, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Process record with an executor. Delete will match against the primary key column to find the record to delete.

func (processQuery) DeleteAll

func (q processQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (processQuery) DeleteAllSlice

func (q processQuery) DeleteAllSlice(o ProcessSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (processQuery) Exists

func (q processQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (processQuery) Insert

func (q processQuery) Insert(o *Process, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (processQuery) One

func (q processQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Process, error)

One returns a single process record from the query.

func (processQuery) Reload

func (q processQuery) Reload(o *Process, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (processQuery) ReloadAll

func (q processQuery) ReloadAll(o *ProcessSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (processQuery) RemoveApp

func (q processQuery) RemoveApp(o *Process, ctx context.Context, exec boil.ContextExecutor, related *App) error

RemoveApp relationship. Sets o.R.App to nil. Removes o from all passed in related items' relationships struct (Optional).

func (processQuery) RemoveResourceProcessAnnotations

func (q processQuery) RemoveResourceProcessAnnotations(o *Process, ctx context.Context, exec boil.ContextExecutor, related ...*ProcessAnnotation) error

RemoveResourceProcessAnnotations relationships from objects passed in. Removes related items from R.ResourceProcessAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (processQuery) RemoveResourceProcessLabels

func (q processQuery) RemoveResourceProcessLabels(o *Process, ctx context.Context, exec boil.ContextExecutor, related ...*ProcessLabel) error

RemoveResourceProcessLabels relationships from objects passed in. Removes related items from R.ResourceProcessLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (processQuery) ResourceProcessAnnotations

func (q processQuery) ResourceProcessAnnotations(o *Process, mods ...qm.QueryMod) processAnnotationQuery

ResourceProcessAnnotations retrieves all the process_annotation's ProcessAnnotations with an executor via resource_guid column.

func (processQuery) ResourceProcessLabels

func (q processQuery) ResourceProcessLabels(o *Process, mods ...qm.QueryMod) processLabelQuery

ResourceProcessLabels retrieves all the process_label's ProcessLabels with an executor via resource_guid column.

func (processQuery) SetApp

func (q processQuery) SetApp(o *Process, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetApp of the process to the related item. Sets o.R.App to related. Adds o to related.R.Processes.

func (processQuery) SetResourceProcessAnnotations

func (q processQuery) SetResourceProcessAnnotations(o *Process, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ProcessAnnotation) error

SetResourceProcessAnnotations removes all previously related items of the process replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceProcessAnnotations accordingly. Replaces o.R.ResourceProcessAnnotations with related. Sets related.R.Resource's ResourceProcessAnnotations accordingly.

func (processQuery) SetResourceProcessLabels

func (q processQuery) SetResourceProcessLabels(o *Process, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ProcessLabel) error

SetResourceProcessLabels removes all previously related items of the process replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceProcessLabels accordingly. Replaces o.R.ResourceProcessLabels with related. Sets related.R.Resource's ResourceProcessLabels accordingly.

func (processQuery) Update

func (q processQuery) Update(o *Process, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Process. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (processQuery) UpdateAll

func (q processQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (processQuery) UpdateAllSlice

func (q processQuery) UpdateAllSlice(o ProcessSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (processQuery) Upsert

func (q processQuery) Upsert(o *Process, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type processR

processR is where relationships are stored.

type processR struct {
    App                        *App                   `boil:"App" json:"App" toml:"App" yaml:"App"`
    AppAppEvents               AppEventSlice          `boil:"AppAppEvents" json:"AppAppEvents" toml:"AppAppEvents" yaml:"AppAppEvents"`
    ResourceProcessAnnotations ProcessAnnotationSlice `boil:"ResourceProcessAnnotations" json:"ResourceProcessAnnotations" toml:"ResourceProcessAnnotations" yaml:"ResourceProcessAnnotations"`
    ResourceProcessLabels      ProcessLabelSlice      `boil:"ResourceProcessLabels" json:"ResourceProcessLabels" toml:"ResourceProcessLabels" yaml:"ResourceProcessLabels"`
}

func (*processR) NewStruct

func (*processR) NewStruct() *processR

NewStruct creates a new relationship struct

type quotaDefinitionL

quotaDefinitionL is where Load methods for each relationship are stored.

type quotaDefinitionL struct{}

func (quotaDefinitionL) LoadOrganizations

func (quotaDefinitionL) LoadOrganizations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeQuotaDefinition interface{}, mods queries.Applicator) error

LoadOrganizations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type quotaDefinitionQuery

type quotaDefinitionQuery struct {
    *queries.Query
}

func QuotaDefinitions

func QuotaDefinitions(mods ...qm.QueryMod) quotaDefinitionQuery

QuotaDefinitions retrieves all the records using an executor.

func (quotaDefinitionQuery) AddOrganizations

func (q quotaDefinitionQuery) AddOrganizations(o *QuotaDefinition, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Organization) error

AddOrganizations adds the given related objects to the existing relationships of the quota_definition\, optionally inserting them as new records. Appends related to o.R.Organizations. Sets related.R.QuotaDefinition appropriately.

func (quotaDefinitionQuery) All

func (q quotaDefinitionQuery) All(ctx context.Context, exec boil.ContextExecutor) (QuotaDefinitionSlice, error)

All returns all QuotaDefinition records from the query.

func (quotaDefinitionQuery) Count

func (q quotaDefinitionQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all QuotaDefinition records in the query.

func (quotaDefinitionQuery) Delete

func (q quotaDefinitionQuery) Delete(o *QuotaDefinition, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single QuotaDefinition record with an executor. Delete will match against the primary key column to find the record to delete.

func (quotaDefinitionQuery) DeleteAll

func (q quotaDefinitionQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (quotaDefinitionQuery) DeleteAllSlice

func (q quotaDefinitionQuery) DeleteAllSlice(o QuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (quotaDefinitionQuery) Exists

func (q quotaDefinitionQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (quotaDefinitionQuery) Insert

func (q quotaDefinitionQuery) Insert(o *QuotaDefinition, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (quotaDefinitionQuery) One

func (q quotaDefinitionQuery) One(ctx context.Context, exec boil.ContextExecutor) (*QuotaDefinition, error)

One returns a single quotaDefinition record from the query.

func (quotaDefinitionQuery) Organizations

func (q quotaDefinitionQuery) Organizations(o *QuotaDefinition, mods ...qm.QueryMod) organizationQuery

Organizations retrieves all the organization's Organizations with an executor.

func (quotaDefinitionQuery) Reload

func (q quotaDefinitionQuery) Reload(o *QuotaDefinition, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (quotaDefinitionQuery) ReloadAll

func (q quotaDefinitionQuery) ReloadAll(o *QuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (quotaDefinitionQuery) Update

func (q quotaDefinitionQuery) Update(o *QuotaDefinition, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the QuotaDefinition. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (quotaDefinitionQuery) UpdateAll

func (q quotaDefinitionQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (quotaDefinitionQuery) UpdateAllSlice

func (q quotaDefinitionQuery) UpdateAllSlice(o QuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (quotaDefinitionQuery) Upsert

func (q quotaDefinitionQuery) Upsert(o *QuotaDefinition, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type quotaDefinitionR

quotaDefinitionR is where relationships are stored.

type quotaDefinitionR struct {
    Organizations OrganizationSlice `boil:"Organizations" json:"Organizations" toml:"Organizations" yaml:"Organizations"`
}

func (*quotaDefinitionR) NewStruct

func (*quotaDefinitionR) NewStruct() *quotaDefinitionR

NewStruct creates a new relationship struct

type requestCountL

requestCountL is where Load methods for each relationship are stored.

type requestCountL struct{}

type requestCountQuery

type requestCountQuery struct {
    *queries.Query
}

func RequestCounts

func RequestCounts(mods ...qm.QueryMod) requestCountQuery

RequestCounts retrieves all the records using an executor.

func (requestCountQuery) All

func (q requestCountQuery) All(ctx context.Context, exec boil.ContextExecutor) (RequestCountSlice, error)

All returns all RequestCount records from the query.

func (requestCountQuery) Count

func (q requestCountQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RequestCount records in the query.

func (requestCountQuery) Delete

func (q requestCountQuery) Delete(o *RequestCount, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RequestCount record with an executor. Delete will match against the primary key column to find the record to delete.

func (requestCountQuery) DeleteAll

func (q requestCountQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (requestCountQuery) DeleteAllSlice

func (q requestCountQuery) DeleteAllSlice(o RequestCountSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (requestCountQuery) Exists

func (q requestCountQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (requestCountQuery) Insert

func (q requestCountQuery) Insert(o *RequestCount, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (requestCountQuery) One

func (q requestCountQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RequestCount, error)

One returns a single requestCount record from the query.

func (requestCountQuery) Reload

func (q requestCountQuery) Reload(o *RequestCount, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (requestCountQuery) ReloadAll

func (q requestCountQuery) ReloadAll(o *RequestCountSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (requestCountQuery) Update

func (q requestCountQuery) Update(o *RequestCount, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RequestCount. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (requestCountQuery) UpdateAll

func (q requestCountQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (requestCountQuery) UpdateAllSlice

func (q requestCountQuery) UpdateAllSlice(o RequestCountSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (requestCountQuery) Upsert

func (q requestCountQuery) Upsert(o *RequestCount, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type requestCountR

requestCountR is where relationships are stored.

type requestCountR struct {
}

func (*requestCountR) NewStruct

func (*requestCountR) NewStruct() *requestCountR

NewStruct creates a new relationship struct

type revisionAnnotationL

revisionAnnotationL is where Load methods for each relationship are stored.

type revisionAnnotationL struct{}

func (revisionAnnotationL) LoadResource

func (revisionAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRevisionAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type revisionAnnotationQuery

type revisionAnnotationQuery struct {
    *queries.Query
}

func RevisionAnnotations

func RevisionAnnotations(mods ...qm.QueryMod) revisionAnnotationQuery

RevisionAnnotations retrieves all the records using an executor.

func (revisionAnnotationQuery) All

func (q revisionAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (RevisionAnnotationSlice, error)

All returns all RevisionAnnotation records from the query.

func (revisionAnnotationQuery) Count

func (q revisionAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RevisionAnnotation records in the query.

func (revisionAnnotationQuery) Delete

func (q revisionAnnotationQuery) Delete(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RevisionAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (revisionAnnotationQuery) DeleteAll

func (q revisionAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (revisionAnnotationQuery) DeleteAllSlice

func (q revisionAnnotationQuery) DeleteAllSlice(o RevisionAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (revisionAnnotationQuery) Exists

func (q revisionAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (revisionAnnotationQuery) Insert

func (q revisionAnnotationQuery) Insert(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (revisionAnnotationQuery) One

func (q revisionAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RevisionAnnotation, error)

One returns a single revisionAnnotation record from the query.

func (revisionAnnotationQuery) Reload

func (q revisionAnnotationQuery) Reload(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (revisionAnnotationQuery) ReloadAll

func (q revisionAnnotationQuery) ReloadAll(o *RevisionAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (revisionAnnotationQuery) RemoveResource

func (q revisionAnnotationQuery) RemoveResource(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Revision) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (revisionAnnotationQuery) Resource

func (q revisionAnnotationQuery) Resource(o *RevisionAnnotation, mods ...qm.QueryMod) revisionQuery

Resource pointed to by the foreign key.

func (revisionAnnotationQuery) SetResource

func (q revisionAnnotationQuery) SetResource(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Revision) error

SetResource of the revisionAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceRevisionAnnotations.

func (revisionAnnotationQuery) Update

func (q revisionAnnotationQuery) Update(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RevisionAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (revisionAnnotationQuery) UpdateAll

func (q revisionAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (revisionAnnotationQuery) UpdateAllSlice

func (q revisionAnnotationQuery) UpdateAllSlice(o RevisionAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (revisionAnnotationQuery) Upsert

func (q revisionAnnotationQuery) Upsert(o *RevisionAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type revisionAnnotationR

revisionAnnotationR is where relationships are stored.

type revisionAnnotationR struct {
    Resource *Revision `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*revisionAnnotationR) NewStruct

func (*revisionAnnotationR) NewStruct() *revisionAnnotationR

NewStruct creates a new relationship struct

type revisionL

revisionL is where Load methods for each relationship are stored.

type revisionL struct{}

func (revisionL) LoadApp

func (revisionL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRevision interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (revisionL) LoadResourceRevisionAnnotations

func (revisionL) LoadResourceRevisionAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRevision interface{}, mods queries.Applicator) error

LoadResourceRevisionAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (revisionL) LoadResourceRevisionLabels

func (revisionL) LoadResourceRevisionLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRevision interface{}, mods queries.Applicator) error

LoadResourceRevisionLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (revisionL) LoadRevisionProcessCommands

func (revisionL) LoadRevisionProcessCommands(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRevision interface{}, mods queries.Applicator) error

LoadRevisionProcessCommands allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (revisionL) LoadRevisionSidecars

func (revisionL) LoadRevisionSidecars(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRevision interface{}, mods queries.Applicator) error

LoadRevisionSidecars allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type revisionLabelL

revisionLabelL is where Load methods for each relationship are stored.

type revisionLabelL struct{}

func (revisionLabelL) LoadResource

func (revisionLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRevisionLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type revisionLabelQuery

type revisionLabelQuery struct {
    *queries.Query
}

func RevisionLabels

func RevisionLabels(mods ...qm.QueryMod) revisionLabelQuery

RevisionLabels retrieves all the records using an executor.

func (revisionLabelQuery) All

func (q revisionLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (RevisionLabelSlice, error)

All returns all RevisionLabel records from the query.

func (revisionLabelQuery) Count

func (q revisionLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RevisionLabel records in the query.

func (revisionLabelQuery) Delete

func (q revisionLabelQuery) Delete(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RevisionLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (revisionLabelQuery) DeleteAll

func (q revisionLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (revisionLabelQuery) DeleteAllSlice

func (q revisionLabelQuery) DeleteAllSlice(o RevisionLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (revisionLabelQuery) Exists

func (q revisionLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (revisionLabelQuery) Insert

func (q revisionLabelQuery) Insert(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (revisionLabelQuery) One

func (q revisionLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RevisionLabel, error)

One returns a single revisionLabel record from the query.

func (revisionLabelQuery) Reload

func (q revisionLabelQuery) Reload(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (revisionLabelQuery) ReloadAll

func (q revisionLabelQuery) ReloadAll(o *RevisionLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (revisionLabelQuery) RemoveResource

func (q revisionLabelQuery) RemoveResource(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor, related *Revision) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (revisionLabelQuery) Resource

func (q revisionLabelQuery) Resource(o *RevisionLabel, mods ...qm.QueryMod) revisionQuery

Resource pointed to by the foreign key.

func (revisionLabelQuery) SetResource

func (q revisionLabelQuery) SetResource(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Revision) error

SetResource of the revisionLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceRevisionLabels.

func (revisionLabelQuery) Update

func (q revisionLabelQuery) Update(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RevisionLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (revisionLabelQuery) UpdateAll

func (q revisionLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (revisionLabelQuery) UpdateAllSlice

func (q revisionLabelQuery) UpdateAllSlice(o RevisionLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (revisionLabelQuery) Upsert

func (q revisionLabelQuery) Upsert(o *RevisionLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type revisionLabelR

revisionLabelR is where relationships are stored.

type revisionLabelR struct {
    Resource *Revision `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*revisionLabelR) NewStruct

func (*revisionLabelR) NewStruct() *revisionLabelR

NewStruct creates a new relationship struct

type revisionProcessCommandL

revisionProcessCommandL is where Load methods for each relationship are stored.

type revisionProcessCommandL struct{}

func (revisionProcessCommandL) LoadRevision

func (revisionProcessCommandL) LoadRevision(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRevisionProcessCommand interface{}, mods queries.Applicator) error

LoadRevision allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type revisionProcessCommandQuery

type revisionProcessCommandQuery struct {
    *queries.Query
}

func RevisionProcessCommands

func RevisionProcessCommands(mods ...qm.QueryMod) revisionProcessCommandQuery

RevisionProcessCommands retrieves all the records using an executor.

func (revisionProcessCommandQuery) All

func (q revisionProcessCommandQuery) All(ctx context.Context, exec boil.ContextExecutor) (RevisionProcessCommandSlice, error)

All returns all RevisionProcessCommand records from the query.

func (revisionProcessCommandQuery) Count

func (q revisionProcessCommandQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RevisionProcessCommand records in the query.

func (revisionProcessCommandQuery) Delete

func (q revisionProcessCommandQuery) Delete(o *RevisionProcessCommand, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RevisionProcessCommand record with an executor. Delete will match against the primary key column to find the record to delete.

func (revisionProcessCommandQuery) DeleteAll

func (q revisionProcessCommandQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (revisionProcessCommandQuery) DeleteAllSlice

func (q revisionProcessCommandQuery) DeleteAllSlice(o RevisionProcessCommandSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (revisionProcessCommandQuery) Exists

func (q revisionProcessCommandQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (revisionProcessCommandQuery) Insert

func (q revisionProcessCommandQuery) Insert(o *RevisionProcessCommand, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (revisionProcessCommandQuery) One

func (q revisionProcessCommandQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RevisionProcessCommand, error)

One returns a single revisionProcessCommand record from the query.

func (revisionProcessCommandQuery) Reload

func (q revisionProcessCommandQuery) Reload(o *RevisionProcessCommand, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (revisionProcessCommandQuery) ReloadAll

func (q revisionProcessCommandQuery) ReloadAll(o *RevisionProcessCommandSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (revisionProcessCommandQuery) Revision

func (q revisionProcessCommandQuery) Revision(o *RevisionProcessCommand, mods ...qm.QueryMod) revisionQuery

Revision pointed to by the foreign key.

func (revisionProcessCommandQuery) SetRevision

func (q revisionProcessCommandQuery) SetRevision(o *RevisionProcessCommand, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Revision) error

SetRevision of the revisionProcessCommand to the related item. Sets o.R.Revision to related. Adds o to related.R.RevisionProcessCommands.

func (revisionProcessCommandQuery) Update

func (q revisionProcessCommandQuery) Update(o *RevisionProcessCommand, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RevisionProcessCommand. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (revisionProcessCommandQuery) UpdateAll

func (q revisionProcessCommandQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (revisionProcessCommandQuery) UpdateAllSlice

func (q revisionProcessCommandQuery) UpdateAllSlice(o RevisionProcessCommandSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (revisionProcessCommandQuery) Upsert

func (q revisionProcessCommandQuery) Upsert(o *RevisionProcessCommand, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type revisionProcessCommandR

revisionProcessCommandR is where relationships are stored.

type revisionProcessCommandR struct {
    Revision *Revision `boil:"Revision" json:"Revision" toml:"Revision" yaml:"Revision"`
}

func (*revisionProcessCommandR) NewStruct

func (*revisionProcessCommandR) NewStruct() *revisionProcessCommandR

NewStruct creates a new relationship struct

type revisionQuery

type revisionQuery struct {
    *queries.Query
}

func Revisions

func Revisions(mods ...qm.QueryMod) revisionQuery

Revisions retrieves all the records using an executor.

func (revisionQuery) AddResourceRevisionAnnotations

func (q revisionQuery) AddResourceRevisionAnnotations(o *Revision, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RevisionAnnotation) error

AddResourceRevisionAnnotations adds the given related objects to the existing relationships of the revision\, optionally inserting them as new records. Appends related to o.R.ResourceRevisionAnnotations. Sets related.R.Resource appropriately.

func (revisionQuery) AddResourceRevisionLabels

func (q revisionQuery) AddResourceRevisionLabels(o *Revision, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RevisionLabel) error

AddResourceRevisionLabels adds the given related objects to the existing relationships of the revision\, optionally inserting them as new records. Appends related to o.R.ResourceRevisionLabels. Sets related.R.Resource appropriately.

func (revisionQuery) AddRevisionProcessCommands

func (q revisionQuery) AddRevisionProcessCommands(o *Revision, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RevisionProcessCommand) error

AddRevisionProcessCommands adds the given related objects to the existing relationships of the revision\, optionally inserting them as new records. Appends related to o.R.RevisionProcessCommands. Sets related.R.Revision appropriately.

func (revisionQuery) AddRevisionSidecars

func (q revisionQuery) AddRevisionSidecars(o *Revision, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RevisionSidecar) error

AddRevisionSidecars adds the given related objects to the existing relationships of the revision\, optionally inserting them as new records. Appends related to o.R.RevisionSidecars. Sets related.R.Revision appropriately.

func (revisionQuery) All

func (q revisionQuery) All(ctx context.Context, exec boil.ContextExecutor) (RevisionSlice, error)

All returns all Revision records from the query.

func (revisionQuery) App

func (q revisionQuery) App(o *Revision, mods ...qm.QueryMod) appQuery

App pointed to by the foreign key.

func (revisionQuery) Count

func (q revisionQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Revision records in the query.

func (revisionQuery) Delete

func (q revisionQuery) Delete(o *Revision, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Revision record with an executor. Delete will match against the primary key column to find the record to delete.

func (revisionQuery) DeleteAll

func (q revisionQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (revisionQuery) DeleteAllSlice

func (q revisionQuery) DeleteAllSlice(o RevisionSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (revisionQuery) Exists

func (q revisionQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (revisionQuery) Insert

func (q revisionQuery) Insert(o *Revision, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (revisionQuery) One

func (q revisionQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Revision, error)

One returns a single revision record from the query.

func (revisionQuery) Reload

func (q revisionQuery) Reload(o *Revision, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (revisionQuery) ReloadAll

func (q revisionQuery) ReloadAll(o *RevisionSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (revisionQuery) RemoveApp

func (q revisionQuery) RemoveApp(o *Revision, ctx context.Context, exec boil.ContextExecutor, related *App) error

RemoveApp relationship. Sets o.R.App to nil. Removes o from all passed in related items' relationships struct (Optional).

func (revisionQuery) RemoveResourceRevisionAnnotations

func (q revisionQuery) RemoveResourceRevisionAnnotations(o *Revision, ctx context.Context, exec boil.ContextExecutor, related ...*RevisionAnnotation) error

RemoveResourceRevisionAnnotations relationships from objects passed in. Removes related items from R.ResourceRevisionAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (revisionQuery) RemoveResourceRevisionLabels

func (q revisionQuery) RemoveResourceRevisionLabels(o *Revision, ctx context.Context, exec boil.ContextExecutor, related ...*RevisionLabel) error

RemoveResourceRevisionLabels relationships from objects passed in. Removes related items from R.ResourceRevisionLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (revisionQuery) ResourceRevisionAnnotations

func (q revisionQuery) ResourceRevisionAnnotations(o *Revision, mods ...qm.QueryMod) revisionAnnotationQuery

ResourceRevisionAnnotations retrieves all the revision_annotation's RevisionAnnotations with an executor via resource_guid column.

func (revisionQuery) ResourceRevisionLabels

func (q revisionQuery) ResourceRevisionLabels(o *Revision, mods ...qm.QueryMod) revisionLabelQuery

ResourceRevisionLabels retrieves all the revision_label's RevisionLabels with an executor via resource_guid column.

func (revisionQuery) RevisionProcessCommands

func (q revisionQuery) RevisionProcessCommands(o *Revision, mods ...qm.QueryMod) revisionProcessCommandQuery

RevisionProcessCommands retrieves all the revision_process_command's RevisionProcessCommands with an executor.

func (revisionQuery) RevisionSidecars

func (q revisionQuery) RevisionSidecars(o *Revision, mods ...qm.QueryMod) revisionSidecarQuery

RevisionSidecars retrieves all the revision_sidecar's RevisionSidecars with an executor.

func (revisionQuery) SetApp

func (q revisionQuery) SetApp(o *Revision, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetApp of the revision to the related item. Sets o.R.App to related. Adds o to related.R.Revisions.

func (revisionQuery) SetResourceRevisionAnnotations

func (q revisionQuery) SetResourceRevisionAnnotations(o *Revision, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RevisionAnnotation) error

SetResourceRevisionAnnotations removes all previously related items of the revision replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceRevisionAnnotations accordingly. Replaces o.R.ResourceRevisionAnnotations with related. Sets related.R.Resource's ResourceRevisionAnnotations accordingly.

func (revisionQuery) SetResourceRevisionLabels

func (q revisionQuery) SetResourceRevisionLabels(o *Revision, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RevisionLabel) error

SetResourceRevisionLabels removes all previously related items of the revision replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceRevisionLabels accordingly. Replaces o.R.ResourceRevisionLabels with related. Sets related.R.Resource's ResourceRevisionLabels accordingly.

func (revisionQuery) Update

func (q revisionQuery) Update(o *Revision, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Revision. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (revisionQuery) UpdateAll

func (q revisionQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (revisionQuery) UpdateAllSlice

func (q revisionQuery) UpdateAllSlice(o RevisionSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (revisionQuery) Upsert

func (q revisionQuery) Upsert(o *Revision, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type revisionR

revisionR is where relationships are stored.

type revisionR struct {
    App                         *App                        `boil:"App" json:"App" toml:"App" yaml:"App"`
    ResourceRevisionAnnotations RevisionAnnotationSlice     `boil:"ResourceRevisionAnnotations" json:"ResourceRevisionAnnotations" toml:"ResourceRevisionAnnotations" yaml:"ResourceRevisionAnnotations"`
    ResourceRevisionLabels      RevisionLabelSlice          `boil:"ResourceRevisionLabels" json:"ResourceRevisionLabels" toml:"ResourceRevisionLabels" yaml:"ResourceRevisionLabels"`
    RevisionProcessCommands     RevisionProcessCommandSlice `boil:"RevisionProcessCommands" json:"RevisionProcessCommands" toml:"RevisionProcessCommands" yaml:"RevisionProcessCommands"`
    RevisionSidecars            RevisionSidecarSlice        `boil:"RevisionSidecars" json:"RevisionSidecars" toml:"RevisionSidecars" yaml:"RevisionSidecars"`
}

func (*revisionR) NewStruct

func (*revisionR) NewStruct() *revisionR

NewStruct creates a new relationship struct

type revisionSidecarL

revisionSidecarL is where Load methods for each relationship are stored.

type revisionSidecarL struct{}

func (revisionSidecarL) LoadRevision

func (revisionSidecarL) LoadRevision(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRevisionSidecar interface{}, mods queries.Applicator) error

LoadRevision allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (revisionSidecarL) LoadRevisionSidecarProcessTypes

func (revisionSidecarL) LoadRevisionSidecarProcessTypes(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRevisionSidecar interface{}, mods queries.Applicator) error

LoadRevisionSidecarProcessTypes allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type revisionSidecarProcessTypeL

revisionSidecarProcessTypeL is where Load methods for each relationship are stored.

type revisionSidecarProcessTypeL struct{}

func (revisionSidecarProcessTypeL) LoadRevisionSidecar

func (revisionSidecarProcessTypeL) LoadRevisionSidecar(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRevisionSidecarProcessType interface{}, mods queries.Applicator) error

LoadRevisionSidecar allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type revisionSidecarProcessTypeQuery

type revisionSidecarProcessTypeQuery struct {
    *queries.Query
}

func RevisionSidecarProcessTypes

func RevisionSidecarProcessTypes(mods ...qm.QueryMod) revisionSidecarProcessTypeQuery

RevisionSidecarProcessTypes retrieves all the records using an executor.

func (revisionSidecarProcessTypeQuery) All

func (q revisionSidecarProcessTypeQuery) All(ctx context.Context, exec boil.ContextExecutor) (RevisionSidecarProcessTypeSlice, error)

All returns all RevisionSidecarProcessType records from the query.

func (revisionSidecarProcessTypeQuery) Count

func (q revisionSidecarProcessTypeQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RevisionSidecarProcessType records in the query.

func (revisionSidecarProcessTypeQuery) Delete

func (q revisionSidecarProcessTypeQuery) Delete(o *RevisionSidecarProcessType, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RevisionSidecarProcessType record with an executor. Delete will match against the primary key column to find the record to delete.

func (revisionSidecarProcessTypeQuery) DeleteAll

func (q revisionSidecarProcessTypeQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (revisionSidecarProcessTypeQuery) DeleteAllSlice

func (q revisionSidecarProcessTypeQuery) DeleteAllSlice(o RevisionSidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (revisionSidecarProcessTypeQuery) Exists

func (q revisionSidecarProcessTypeQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (revisionSidecarProcessTypeQuery) Insert

func (q revisionSidecarProcessTypeQuery) Insert(o *RevisionSidecarProcessType, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (revisionSidecarProcessTypeQuery) One

func (q revisionSidecarProcessTypeQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RevisionSidecarProcessType, error)

One returns a single revisionSidecarProcessType record from the query.

func (revisionSidecarProcessTypeQuery) Reload

func (q revisionSidecarProcessTypeQuery) Reload(o *RevisionSidecarProcessType, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (revisionSidecarProcessTypeQuery) ReloadAll

func (q revisionSidecarProcessTypeQuery) ReloadAll(o *RevisionSidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (revisionSidecarProcessTypeQuery) RevisionSidecar

func (q revisionSidecarProcessTypeQuery) RevisionSidecar(o *RevisionSidecarProcessType, mods ...qm.QueryMod) revisionSidecarQuery

RevisionSidecar pointed to by the foreign key.

func (revisionSidecarProcessTypeQuery) SetRevisionSidecar

func (q revisionSidecarProcessTypeQuery) SetRevisionSidecar(o *RevisionSidecarProcessType, ctx context.Context, exec boil.ContextExecutor, insert bool, related *RevisionSidecar) error

SetRevisionSidecar of the revisionSidecarProcessType to the related item. Sets o.R.RevisionSidecar to related. Adds o to related.R.RevisionSidecarProcessTypes.

func (revisionSidecarProcessTypeQuery) Update

func (q revisionSidecarProcessTypeQuery) Update(o *RevisionSidecarProcessType, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RevisionSidecarProcessType. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (revisionSidecarProcessTypeQuery) UpdateAll

func (q revisionSidecarProcessTypeQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (revisionSidecarProcessTypeQuery) UpdateAllSlice

func (q revisionSidecarProcessTypeQuery) UpdateAllSlice(o RevisionSidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (revisionSidecarProcessTypeQuery) Upsert

func (q revisionSidecarProcessTypeQuery) Upsert(o *RevisionSidecarProcessType, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type revisionSidecarProcessTypeR

revisionSidecarProcessTypeR is where relationships are stored.

type revisionSidecarProcessTypeR struct {
    RevisionSidecar *RevisionSidecar `boil:"RevisionSidecar" json:"RevisionSidecar" toml:"RevisionSidecar" yaml:"RevisionSidecar"`
}

func (*revisionSidecarProcessTypeR) NewStruct

func (*revisionSidecarProcessTypeR) NewStruct() *revisionSidecarProcessTypeR

NewStruct creates a new relationship struct

type revisionSidecarQuery

type revisionSidecarQuery struct {
    *queries.Query
}

func RevisionSidecars

func RevisionSidecars(mods ...qm.QueryMod) revisionSidecarQuery

RevisionSidecars retrieves all the records using an executor.

func (revisionSidecarQuery) AddRevisionSidecarProcessTypes

func (q revisionSidecarQuery) AddRevisionSidecarProcessTypes(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RevisionSidecarProcessType) error

AddRevisionSidecarProcessTypes adds the given related objects to the existing relationships of the revision_sidecar\, optionally inserting them as new records. Appends related to o.R.RevisionSidecarProcessTypes. Sets related.R.RevisionSidecar appropriately.

func (revisionSidecarQuery) All

func (q revisionSidecarQuery) All(ctx context.Context, exec boil.ContextExecutor) (RevisionSidecarSlice, error)

All returns all RevisionSidecar records from the query.

func (revisionSidecarQuery) Count

func (q revisionSidecarQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RevisionSidecar records in the query.

func (revisionSidecarQuery) Delete

func (q revisionSidecarQuery) Delete(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RevisionSidecar record with an executor. Delete will match against the primary key column to find the record to delete.

func (revisionSidecarQuery) DeleteAll

func (q revisionSidecarQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (revisionSidecarQuery) DeleteAllSlice

func (q revisionSidecarQuery) DeleteAllSlice(o RevisionSidecarSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (revisionSidecarQuery) Exists

func (q revisionSidecarQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (revisionSidecarQuery) Insert

func (q revisionSidecarQuery) Insert(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (revisionSidecarQuery) One

func (q revisionSidecarQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RevisionSidecar, error)

One returns a single revisionSidecar record from the query.

func (revisionSidecarQuery) Reload

func (q revisionSidecarQuery) Reload(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (revisionSidecarQuery) ReloadAll

func (q revisionSidecarQuery) ReloadAll(o *RevisionSidecarSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (revisionSidecarQuery) Revision

func (q revisionSidecarQuery) Revision(o *RevisionSidecar, mods ...qm.QueryMod) revisionQuery

Revision pointed to by the foreign key.

func (revisionSidecarQuery) RevisionSidecarProcessTypes

func (q revisionSidecarQuery) RevisionSidecarProcessTypes(o *RevisionSidecar, mods ...qm.QueryMod) revisionSidecarProcessTypeQuery

RevisionSidecarProcessTypes retrieves all the revision_sidecar_process_type's RevisionSidecarProcessTypes with an executor.

func (revisionSidecarQuery) SetRevision

func (q revisionSidecarQuery) SetRevision(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Revision) error

SetRevision of the revisionSidecar to the related item. Sets o.R.Revision to related. Adds o to related.R.RevisionSidecars.

func (revisionSidecarQuery) Update

func (q revisionSidecarQuery) Update(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RevisionSidecar. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (revisionSidecarQuery) UpdateAll

func (q revisionSidecarQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (revisionSidecarQuery) UpdateAllSlice

func (q revisionSidecarQuery) UpdateAllSlice(o RevisionSidecarSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (revisionSidecarQuery) Upsert

func (q revisionSidecarQuery) Upsert(o *RevisionSidecar, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type revisionSidecarR

revisionSidecarR is where relationships are stored.

type revisionSidecarR struct {
    Revision                    *Revision                       `boil:"Revision" json:"Revision" toml:"Revision" yaml:"Revision"`
    RevisionSidecarProcessTypes RevisionSidecarProcessTypeSlice `boil:"RevisionSidecarProcessTypes" json:"RevisionSidecarProcessTypes" toml:"RevisionSidecarProcessTypes" yaml:"RevisionSidecarProcessTypes"`
}

func (*revisionSidecarR) NewStruct

func (*revisionSidecarR) NewStruct() *revisionSidecarR

NewStruct creates a new relationship struct

type routeAnnotationL

routeAnnotationL is where Load methods for each relationship are stored.

type routeAnnotationL struct{}

func (routeAnnotationL) LoadResource

func (routeAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type routeAnnotationQuery

type routeAnnotationQuery struct {
    *queries.Query
}

func RouteAnnotations

func RouteAnnotations(mods ...qm.QueryMod) routeAnnotationQuery

RouteAnnotations retrieves all the records using an executor.

func (routeAnnotationQuery) All

func (q routeAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (RouteAnnotationSlice, error)

All returns all RouteAnnotation records from the query.

func (routeAnnotationQuery) Count

func (q routeAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RouteAnnotation records in the query.

func (routeAnnotationQuery) Delete

func (q routeAnnotationQuery) Delete(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RouteAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (routeAnnotationQuery) DeleteAll

func (q routeAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (routeAnnotationQuery) DeleteAllSlice

func (q routeAnnotationQuery) DeleteAllSlice(o RouteAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (routeAnnotationQuery) Exists

func (q routeAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (routeAnnotationQuery) Insert

func (q routeAnnotationQuery) Insert(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (routeAnnotationQuery) One

func (q routeAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RouteAnnotation, error)

One returns a single routeAnnotation record from the query.

func (routeAnnotationQuery) Reload

func (q routeAnnotationQuery) Reload(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (routeAnnotationQuery) ReloadAll

func (q routeAnnotationQuery) ReloadAll(o *RouteAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (routeAnnotationQuery) RemoveResource

func (q routeAnnotationQuery) RemoveResource(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Route) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (routeAnnotationQuery) Resource

func (q routeAnnotationQuery) Resource(o *RouteAnnotation, mods ...qm.QueryMod) routeQuery

Resource pointed to by the foreign key.

func (routeAnnotationQuery) SetResource

func (q routeAnnotationQuery) SetResource(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Route) error

SetResource of the routeAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceRouteAnnotations.

func (routeAnnotationQuery) Update

func (q routeAnnotationQuery) Update(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RouteAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (routeAnnotationQuery) UpdateAll

func (q routeAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (routeAnnotationQuery) UpdateAllSlice

func (q routeAnnotationQuery) UpdateAllSlice(o RouteAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (routeAnnotationQuery) Upsert

func (q routeAnnotationQuery) Upsert(o *RouteAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type routeAnnotationR

routeAnnotationR is where relationships are stored.

type routeAnnotationR struct {
    Resource *Route `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*routeAnnotationR) NewStruct

func (*routeAnnotationR) NewStruct() *routeAnnotationR

NewStruct creates a new relationship struct

type routeBindingAnnotationL

routeBindingAnnotationL is where Load methods for each relationship are stored.

type routeBindingAnnotationL struct{}

func (routeBindingAnnotationL) LoadResource

func (routeBindingAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteBindingAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type routeBindingAnnotationQuery

type routeBindingAnnotationQuery struct {
    *queries.Query
}

func RouteBindingAnnotations

func RouteBindingAnnotations(mods ...qm.QueryMod) routeBindingAnnotationQuery

RouteBindingAnnotations retrieves all the records using an executor.

func (routeBindingAnnotationQuery) All

func (q routeBindingAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (RouteBindingAnnotationSlice, error)

All returns all RouteBindingAnnotation records from the query.

func (routeBindingAnnotationQuery) Count

func (q routeBindingAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RouteBindingAnnotation records in the query.

func (routeBindingAnnotationQuery) Delete

func (q routeBindingAnnotationQuery) Delete(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RouteBindingAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (routeBindingAnnotationQuery) DeleteAll

func (q routeBindingAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (routeBindingAnnotationQuery) DeleteAllSlice

func (q routeBindingAnnotationQuery) DeleteAllSlice(o RouteBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (routeBindingAnnotationQuery) Exists

func (q routeBindingAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (routeBindingAnnotationQuery) Insert

func (q routeBindingAnnotationQuery) Insert(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (routeBindingAnnotationQuery) One

func (q routeBindingAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RouteBindingAnnotation, error)

One returns a single routeBindingAnnotation record from the query.

func (routeBindingAnnotationQuery) Reload

func (q routeBindingAnnotationQuery) Reload(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (routeBindingAnnotationQuery) ReloadAll

func (q routeBindingAnnotationQuery) ReloadAll(o *RouteBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (routeBindingAnnotationQuery) RemoveResource

func (q routeBindingAnnotationQuery) RemoveResource(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, related *RouteBinding) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (routeBindingAnnotationQuery) Resource

func (q routeBindingAnnotationQuery) Resource(o *RouteBindingAnnotation, mods ...qm.QueryMod) routeBindingQuery

Resource pointed to by the foreign key.

func (routeBindingAnnotationQuery) SetResource

func (q routeBindingAnnotationQuery) SetResource(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *RouteBinding) error

SetResource of the routeBindingAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceRouteBindingAnnotations.

func (routeBindingAnnotationQuery) Update

func (q routeBindingAnnotationQuery) Update(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RouteBindingAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (routeBindingAnnotationQuery) UpdateAll

func (q routeBindingAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (routeBindingAnnotationQuery) UpdateAllSlice

func (q routeBindingAnnotationQuery) UpdateAllSlice(o RouteBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (routeBindingAnnotationQuery) Upsert

func (q routeBindingAnnotationQuery) Upsert(o *RouteBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type routeBindingAnnotationR

routeBindingAnnotationR is where relationships are stored.

type routeBindingAnnotationR struct {
    Resource *RouteBinding `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*routeBindingAnnotationR) NewStruct

func (*routeBindingAnnotationR) NewStruct() *routeBindingAnnotationR

NewStruct creates a new relationship struct

type routeBindingL

routeBindingL is where Load methods for each relationship are stored.

type routeBindingL struct{}

func (routeBindingL) LoadResourceRouteBindingAnnotations

func (routeBindingL) LoadResourceRouteBindingAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteBinding interface{}, mods queries.Applicator) error

LoadResourceRouteBindingAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (routeBindingL) LoadResourceRouteBindingLabels

func (routeBindingL) LoadResourceRouteBindingLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteBinding interface{}, mods queries.Applicator) error

LoadResourceRouteBindingLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (routeBindingL) LoadRoute

func (routeBindingL) LoadRoute(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteBinding interface{}, mods queries.Applicator) error

LoadRoute allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (routeBindingL) LoadRouteBindingOperation

func (routeBindingL) LoadRouteBindingOperation(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteBinding interface{}, mods queries.Applicator) error

LoadRouteBindingOperation allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-1 relationship.

func (routeBindingL) LoadServiceInstance

func (routeBindingL) LoadServiceInstance(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteBinding interface{}, mods queries.Applicator) error

LoadServiceInstance allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type routeBindingLabelL

routeBindingLabelL is where Load methods for each relationship are stored.

type routeBindingLabelL struct{}

func (routeBindingLabelL) LoadResource

func (routeBindingLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteBindingLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type routeBindingLabelQuery

type routeBindingLabelQuery struct {
    *queries.Query
}

func RouteBindingLabels

func RouteBindingLabels(mods ...qm.QueryMod) routeBindingLabelQuery

RouteBindingLabels retrieves all the records using an executor.

func (routeBindingLabelQuery) All

func (q routeBindingLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (RouteBindingLabelSlice, error)

All returns all RouteBindingLabel records from the query.

func (routeBindingLabelQuery) Count

func (q routeBindingLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RouteBindingLabel records in the query.

func (routeBindingLabelQuery) Delete

func (q routeBindingLabelQuery) Delete(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RouteBindingLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (routeBindingLabelQuery) DeleteAll

func (q routeBindingLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (routeBindingLabelQuery) DeleteAllSlice

func (q routeBindingLabelQuery) DeleteAllSlice(o RouteBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (routeBindingLabelQuery) Exists

func (q routeBindingLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (routeBindingLabelQuery) Insert

func (q routeBindingLabelQuery) Insert(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (routeBindingLabelQuery) One

func (q routeBindingLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RouteBindingLabel, error)

One returns a single routeBindingLabel record from the query.

func (routeBindingLabelQuery) Reload

func (q routeBindingLabelQuery) Reload(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (routeBindingLabelQuery) ReloadAll

func (q routeBindingLabelQuery) ReloadAll(o *RouteBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (routeBindingLabelQuery) RemoveResource

func (q routeBindingLabelQuery) RemoveResource(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor, related *RouteBinding) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (routeBindingLabelQuery) Resource

func (q routeBindingLabelQuery) Resource(o *RouteBindingLabel, mods ...qm.QueryMod) routeBindingQuery

Resource pointed to by the foreign key.

func (routeBindingLabelQuery) SetResource

func (q routeBindingLabelQuery) SetResource(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *RouteBinding) error

SetResource of the routeBindingLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceRouteBindingLabels.

func (routeBindingLabelQuery) Update

func (q routeBindingLabelQuery) Update(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RouteBindingLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (routeBindingLabelQuery) UpdateAll

func (q routeBindingLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (routeBindingLabelQuery) UpdateAllSlice

func (q routeBindingLabelQuery) UpdateAllSlice(o RouteBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (routeBindingLabelQuery) Upsert

func (q routeBindingLabelQuery) Upsert(o *RouteBindingLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type routeBindingLabelR

routeBindingLabelR is where relationships are stored.

type routeBindingLabelR struct {
    Resource *RouteBinding `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*routeBindingLabelR) NewStruct

func (*routeBindingLabelR) NewStruct() *routeBindingLabelR

NewStruct creates a new relationship struct

type routeBindingOperationL

routeBindingOperationL is where Load methods for each relationship are stored.

type routeBindingOperationL struct{}

func (routeBindingOperationL) LoadRouteBinding

func (routeBindingOperationL) LoadRouteBinding(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteBindingOperation interface{}, mods queries.Applicator) error

LoadRouteBinding allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type routeBindingOperationQuery

type routeBindingOperationQuery struct {
    *queries.Query
}

func RouteBindingOperations

func RouteBindingOperations(mods ...qm.QueryMod) routeBindingOperationQuery

RouteBindingOperations retrieves all the records using an executor.

func (routeBindingOperationQuery) All

func (q routeBindingOperationQuery) All(ctx context.Context, exec boil.ContextExecutor) (RouteBindingOperationSlice, error)

All returns all RouteBindingOperation records from the query.

func (routeBindingOperationQuery) Count

func (q routeBindingOperationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RouteBindingOperation records in the query.

func (routeBindingOperationQuery) Delete

func (q routeBindingOperationQuery) Delete(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RouteBindingOperation record with an executor. Delete will match against the primary key column to find the record to delete.

func (routeBindingOperationQuery) DeleteAll

func (q routeBindingOperationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (routeBindingOperationQuery) DeleteAllSlice

func (q routeBindingOperationQuery) DeleteAllSlice(o RouteBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (routeBindingOperationQuery) Exists

func (q routeBindingOperationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (routeBindingOperationQuery) Insert

func (q routeBindingOperationQuery) Insert(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (routeBindingOperationQuery) One

func (q routeBindingOperationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RouteBindingOperation, error)

One returns a single routeBindingOperation record from the query.

func (routeBindingOperationQuery) Reload

func (q routeBindingOperationQuery) Reload(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (routeBindingOperationQuery) ReloadAll

func (q routeBindingOperationQuery) ReloadAll(o *RouteBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (routeBindingOperationQuery) RemoveRouteBinding

func (q routeBindingOperationQuery) RemoveRouteBinding(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor, related *RouteBinding) error

RemoveRouteBinding relationship. Sets o.R.RouteBinding to nil. Removes o from all passed in related items' relationships struct (Optional).

func (routeBindingOperationQuery) RouteBinding

func (q routeBindingOperationQuery) RouteBinding(o *RouteBindingOperation, mods ...qm.QueryMod) routeBindingQuery

RouteBinding pointed to by the foreign key.

func (routeBindingOperationQuery) SetRouteBinding

func (q routeBindingOperationQuery) SetRouteBinding(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *RouteBinding) error

SetRouteBinding of the routeBindingOperation to the related item. Sets o.R.RouteBinding to related. Adds o to related.R.RouteBindingOperation.

func (routeBindingOperationQuery) Update

func (q routeBindingOperationQuery) Update(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RouteBindingOperation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (routeBindingOperationQuery) UpdateAll

func (q routeBindingOperationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (routeBindingOperationQuery) UpdateAllSlice

func (q routeBindingOperationQuery) UpdateAllSlice(o RouteBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (routeBindingOperationQuery) Upsert

func (q routeBindingOperationQuery) Upsert(o *RouteBindingOperation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type routeBindingOperationR

routeBindingOperationR is where relationships are stored.

type routeBindingOperationR struct {
    RouteBinding *RouteBinding `boil:"RouteBinding" json:"RouteBinding" toml:"RouteBinding" yaml:"RouteBinding"`
}

func (*routeBindingOperationR) NewStruct

func (*routeBindingOperationR) NewStruct() *routeBindingOperationR

NewStruct creates a new relationship struct

type routeBindingQuery

type routeBindingQuery struct {
    *queries.Query
}

func RouteBindings

func RouteBindings(mods ...qm.QueryMod) routeBindingQuery

RouteBindings retrieves all the records using an executor.

func (routeBindingQuery) AddResourceRouteBindingAnnotations

func (q routeBindingQuery) AddResourceRouteBindingAnnotations(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteBindingAnnotation) error

AddResourceRouteBindingAnnotations adds the given related objects to the existing relationships of the route_binding\, optionally inserting them as new records. Appends related to o.R.ResourceRouteBindingAnnotations. Sets related.R.Resource appropriately.

func (routeBindingQuery) AddResourceRouteBindingLabels

func (q routeBindingQuery) AddResourceRouteBindingLabels(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteBindingLabel) error

AddResourceRouteBindingLabels adds the given related objects to the existing relationships of the route_binding\, optionally inserting them as new records. Appends related to o.R.ResourceRouteBindingLabels. Sets related.R.Resource appropriately.

func (routeBindingQuery) All

func (q routeBindingQuery) All(ctx context.Context, exec boil.ContextExecutor) (RouteBindingSlice, error)

All returns all RouteBinding records from the query.

func (routeBindingQuery) Count

func (q routeBindingQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RouteBinding records in the query.

func (routeBindingQuery) Delete

func (q routeBindingQuery) Delete(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RouteBinding record with an executor. Delete will match against the primary key column to find the record to delete.

func (routeBindingQuery) DeleteAll

func (q routeBindingQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (routeBindingQuery) DeleteAllSlice

func (q routeBindingQuery) DeleteAllSlice(o RouteBindingSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (routeBindingQuery) Exists

func (q routeBindingQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (routeBindingQuery) Insert

func (q routeBindingQuery) Insert(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (routeBindingQuery) One

func (q routeBindingQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RouteBinding, error)

One returns a single routeBinding record from the query.

func (routeBindingQuery) Reload

func (q routeBindingQuery) Reload(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (routeBindingQuery) ReloadAll

func (q routeBindingQuery) ReloadAll(o *RouteBindingSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (routeBindingQuery) RemoveResourceRouteBindingAnnotations

func (q routeBindingQuery) RemoveResourceRouteBindingAnnotations(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, related ...*RouteBindingAnnotation) error

RemoveResourceRouteBindingAnnotations relationships from objects passed in. Removes related items from R.ResourceRouteBindingAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (routeBindingQuery) RemoveResourceRouteBindingLabels

func (q routeBindingQuery) RemoveResourceRouteBindingLabels(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, related ...*RouteBindingLabel) error

RemoveResourceRouteBindingLabels relationships from objects passed in. Removes related items from R.ResourceRouteBindingLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (routeBindingQuery) RemoveRoute

func (q routeBindingQuery) RemoveRoute(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, related *Route) error

RemoveRoute relationship. Sets o.R.Route to nil. Removes o from all passed in related items' relationships struct (Optional).

func (routeBindingQuery) RemoveRouteBindingOperation

func (q routeBindingQuery) RemoveRouteBindingOperation(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, related *RouteBindingOperation) error

RemoveRouteBindingOperation relationship. Sets o.R.RouteBindingOperation to nil. Removes o from all passed in related items' relationships struct (Optional).

func (routeBindingQuery) RemoveServiceInstance

func (q routeBindingQuery) RemoveServiceInstance(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, related *ServiceInstance) error

RemoveServiceInstance relationship. Sets o.R.ServiceInstance to nil. Removes o from all passed in related items' relationships struct (Optional).

func (routeBindingQuery) ResourceRouteBindingAnnotations

func (q routeBindingQuery) ResourceRouteBindingAnnotations(o *RouteBinding, mods ...qm.QueryMod) routeBindingAnnotationQuery

ResourceRouteBindingAnnotations retrieves all the route_binding_annotation's RouteBindingAnnotations with an executor via resource_guid column.

func (routeBindingQuery) ResourceRouteBindingLabels

func (q routeBindingQuery) ResourceRouteBindingLabels(o *RouteBinding, mods ...qm.QueryMod) routeBindingLabelQuery

ResourceRouteBindingLabels retrieves all the route_binding_label's RouteBindingLabels with an executor via resource_guid column.

func (routeBindingQuery) Route

func (q routeBindingQuery) Route(o *RouteBinding, mods ...qm.QueryMod) routeQuery

Route pointed to by the foreign key.

func (routeBindingQuery) RouteBindingOperation

func (q routeBindingQuery) RouteBindingOperation(o *RouteBinding, mods ...qm.QueryMod) routeBindingOperationQuery

RouteBindingOperation pointed to by the foreign key.

func (routeBindingQuery) ServiceInstance

func (q routeBindingQuery) ServiceInstance(o *RouteBinding, mods ...qm.QueryMod) serviceInstanceQuery

ServiceInstance pointed to by the foreign key.

func (routeBindingQuery) SetResourceRouteBindingAnnotations

func (q routeBindingQuery) SetResourceRouteBindingAnnotations(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteBindingAnnotation) error

SetResourceRouteBindingAnnotations removes all previously related items of the route_binding replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceRouteBindingAnnotations accordingly. Replaces o.R.ResourceRouteBindingAnnotations with related. Sets related.R.Resource's ResourceRouteBindingAnnotations accordingly.

func (routeBindingQuery) SetResourceRouteBindingLabels

func (q routeBindingQuery) SetResourceRouteBindingLabels(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteBindingLabel) error

SetResourceRouteBindingLabels removes all previously related items of the route_binding replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceRouteBindingLabels accordingly. Replaces o.R.ResourceRouteBindingLabels with related. Sets related.R.Resource's ResourceRouteBindingLabels accordingly.

func (routeBindingQuery) SetRoute

func (q routeBindingQuery) SetRoute(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Route) error

SetRoute of the routeBinding to the related item. Sets o.R.Route to related. Adds o to related.R.RouteBindings.

func (routeBindingQuery) SetRouteBindingOperation

func (q routeBindingQuery) SetRouteBindingOperation(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related *RouteBindingOperation) error

SetRouteBindingOperation of the routeBinding to the related item. Sets o.R.RouteBindingOperation to related. Adds o to related.R.RouteBinding.

func (routeBindingQuery) SetServiceInstance

func (q routeBindingQuery) SetServiceInstance(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceInstance) error

SetServiceInstance of the routeBinding to the related item. Sets o.R.ServiceInstance to related. Adds o to related.R.RouteBindings.

func (routeBindingQuery) Update

func (q routeBindingQuery) Update(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RouteBinding. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (routeBindingQuery) UpdateAll

func (q routeBindingQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (routeBindingQuery) UpdateAllSlice

func (q routeBindingQuery) UpdateAllSlice(o RouteBindingSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (routeBindingQuery) Upsert

func (q routeBindingQuery) Upsert(o *RouteBinding, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type routeBindingR

routeBindingR is where relationships are stored.

type routeBindingR struct {
    Route                           *Route                      `boil:"Route" json:"Route" toml:"Route" yaml:"Route"`
    ServiceInstance                 *ServiceInstance            `boil:"ServiceInstance" json:"ServiceInstance" toml:"ServiceInstance" yaml:"ServiceInstance"`
    RouteBindingOperation           *RouteBindingOperation      `boil:"RouteBindingOperation" json:"RouteBindingOperation" toml:"RouteBindingOperation" yaml:"RouteBindingOperation"`
    ResourceRouteBindingAnnotations RouteBindingAnnotationSlice `boil:"ResourceRouteBindingAnnotations" json:"ResourceRouteBindingAnnotations" toml:"ResourceRouteBindingAnnotations" yaml:"ResourceRouteBindingAnnotations"`
    ResourceRouteBindingLabels      RouteBindingLabelSlice      `boil:"ResourceRouteBindingLabels" json:"ResourceRouteBindingLabels" toml:"ResourceRouteBindingLabels" yaml:"ResourceRouteBindingLabels"`
}

func (*routeBindingR) NewStruct

func (*routeBindingR) NewStruct() *routeBindingR

NewStruct creates a new relationship struct

type routeL

routeL is where Load methods for each relationship are stored.

type routeL struct{}

func (routeL) LoadDomain

func (routeL) LoadDomain(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRoute interface{}, mods queries.Applicator) error

LoadDomain allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (routeL) LoadResourceRouteAnnotations

func (routeL) LoadResourceRouteAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRoute interface{}, mods queries.Applicator) error

LoadResourceRouteAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (routeL) LoadResourceRouteLabels

func (routeL) LoadResourceRouteLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRoute interface{}, mods queries.Applicator) error

LoadResourceRouteLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (routeL) LoadRouteBindings

func (routeL) LoadRouteBindings(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRoute interface{}, mods queries.Applicator) error

LoadRouteBindings allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (routeL) LoadRouteMappings

func (routeL) LoadRouteMappings(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRoute interface{}, mods queries.Applicator) error

LoadRouteMappings allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (routeL) LoadSpace

func (routeL) LoadSpace(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRoute interface{}, mods queries.Applicator) error

LoadSpace allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type routeLabelL

routeLabelL is where Load methods for each relationship are stored.

type routeLabelL struct{}

func (routeLabelL) LoadResource

func (routeLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type routeLabelQuery

type routeLabelQuery struct {
    *queries.Query
}

func RouteLabels

func RouteLabels(mods ...qm.QueryMod) routeLabelQuery

RouteLabels retrieves all the records using an executor.

func (routeLabelQuery) All

func (q routeLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (RouteLabelSlice, error)

All returns all RouteLabel records from the query.

func (routeLabelQuery) Count

func (q routeLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RouteLabel records in the query.

func (routeLabelQuery) Delete

func (q routeLabelQuery) Delete(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RouteLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (routeLabelQuery) DeleteAll

func (q routeLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (routeLabelQuery) DeleteAllSlice

func (q routeLabelQuery) DeleteAllSlice(o RouteLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (routeLabelQuery) Exists

func (q routeLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (routeLabelQuery) Insert

func (q routeLabelQuery) Insert(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (routeLabelQuery) One

func (q routeLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RouteLabel, error)

One returns a single routeLabel record from the query.

func (routeLabelQuery) Reload

func (q routeLabelQuery) Reload(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (routeLabelQuery) ReloadAll

func (q routeLabelQuery) ReloadAll(o *RouteLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (routeLabelQuery) RemoveResource

func (q routeLabelQuery) RemoveResource(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor, related *Route) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (routeLabelQuery) Resource

func (q routeLabelQuery) Resource(o *RouteLabel, mods ...qm.QueryMod) routeQuery

Resource pointed to by the foreign key.

func (routeLabelQuery) SetResource

func (q routeLabelQuery) SetResource(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Route) error

SetResource of the routeLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceRouteLabels.

func (routeLabelQuery) Update

func (q routeLabelQuery) Update(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RouteLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (routeLabelQuery) UpdateAll

func (q routeLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (routeLabelQuery) UpdateAllSlice

func (q routeLabelQuery) UpdateAllSlice(o RouteLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (routeLabelQuery) Upsert

func (q routeLabelQuery) Upsert(o *RouteLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type routeLabelR

routeLabelR is where relationships are stored.

type routeLabelR struct {
    Resource *Route `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*routeLabelR) NewStruct

func (*routeLabelR) NewStruct() *routeLabelR

NewStruct creates a new relationship struct

type routeMappingL

routeMappingL is where Load methods for each relationship are stored.

type routeMappingL struct{}

func (routeMappingL) LoadApp

func (routeMappingL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteMapping interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (routeMappingL) LoadRoute

func (routeMappingL) LoadRoute(ctx context.Context, e boil.ContextExecutor, singular bool, maybeRouteMapping interface{}, mods queries.Applicator) error

LoadRoute allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type routeMappingQuery

type routeMappingQuery struct {
    *queries.Query
}

func RouteMappings

func RouteMappings(mods ...qm.QueryMod) routeMappingQuery

RouteMappings retrieves all the records using an executor.

func (routeMappingQuery) All

func (q routeMappingQuery) All(ctx context.Context, exec boil.ContextExecutor) (RouteMappingSlice, error)

All returns all RouteMapping records from the query.

func (routeMappingQuery) App

func (q routeMappingQuery) App(o *RouteMapping, mods ...qm.QueryMod) appQuery

App pointed to by the foreign key.

func (routeMappingQuery) Count

func (q routeMappingQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all RouteMapping records in the query.

func (routeMappingQuery) Delete

func (q routeMappingQuery) Delete(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single RouteMapping record with an executor. Delete will match against the primary key column to find the record to delete.

func (routeMappingQuery) DeleteAll

func (q routeMappingQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (routeMappingQuery) DeleteAllSlice

func (q routeMappingQuery) DeleteAllSlice(o RouteMappingSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (routeMappingQuery) Exists

func (q routeMappingQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (routeMappingQuery) Insert

func (q routeMappingQuery) Insert(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (routeMappingQuery) One

func (q routeMappingQuery) One(ctx context.Context, exec boil.ContextExecutor) (*RouteMapping, error)

One returns a single routeMapping record from the query.

func (routeMappingQuery) Reload

func (q routeMappingQuery) Reload(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (routeMappingQuery) ReloadAll

func (q routeMappingQuery) ReloadAll(o *RouteMappingSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (routeMappingQuery) Route

func (q routeMappingQuery) Route(o *RouteMapping, mods ...qm.QueryMod) routeQuery

Route pointed to by the foreign key.

func (routeMappingQuery) SetApp

func (q routeMappingQuery) SetApp(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetApp of the routeMapping to the related item. Sets o.R.App to related. Adds o to related.R.RouteMappings.

func (routeMappingQuery) SetRoute

func (q routeMappingQuery) SetRoute(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Route) error

SetRoute of the routeMapping to the related item. Sets o.R.Route to related. Adds o to related.R.RouteMappings.

func (routeMappingQuery) Update

func (q routeMappingQuery) Update(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the RouteMapping. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (routeMappingQuery) UpdateAll

func (q routeMappingQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (routeMappingQuery) UpdateAllSlice

func (q routeMappingQuery) UpdateAllSlice(o RouteMappingSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (routeMappingQuery) Upsert

func (q routeMappingQuery) Upsert(o *RouteMapping, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type routeMappingR

routeMappingR is where relationships are stored.

type routeMappingR struct {
    App   *App   `boil:"App" json:"App" toml:"App" yaml:"App"`
    Route *Route `boil:"Route" json:"Route" toml:"Route" yaml:"Route"`
}

func (*routeMappingR) NewStruct

func (*routeMappingR) NewStruct() *routeMappingR

NewStruct creates a new relationship struct

type routeQuery

type routeQuery struct {
    *queries.Query
}

func Routes

func Routes(mods ...qm.QueryMod) routeQuery

Routes retrieves all the records using an executor.

func (routeQuery) AddResourceRouteAnnotations

func (q routeQuery) AddResourceRouteAnnotations(o *Route, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteAnnotation) error

AddResourceRouteAnnotations adds the given related objects to the existing relationships of the route\, optionally inserting them as new records. Appends related to o.R.ResourceRouteAnnotations. Sets related.R.Resource appropriately.

func (routeQuery) AddResourceRouteLabels

func (q routeQuery) AddResourceRouteLabels(o *Route, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteLabel) error

AddResourceRouteLabels adds the given related objects to the existing relationships of the route\, optionally inserting them as new records. Appends related to o.R.ResourceRouteLabels. Sets related.R.Resource appropriately.

func (routeQuery) AddRouteBindings

func (q routeQuery) AddRouteBindings(o *Route, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteBinding) error

AddRouteBindings adds the given related objects to the existing relationships of the route\, optionally inserting them as new records. Appends related to o.R.RouteBindings. Sets related.R.Route appropriately.

func (routeQuery) AddRouteMappings

func (q routeQuery) AddRouteMappings(o *Route, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteMapping) error

AddRouteMappings adds the given related objects to the existing relationships of the route\, optionally inserting them as new records. Appends related to o.R.RouteMappings. Sets related.R.Route appropriately.

func (routeQuery) All

func (q routeQuery) All(ctx context.Context, exec boil.ContextExecutor) (RouteSlice, error)

All returns all Route records from the query.

func (routeQuery) Count

func (q routeQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Route records in the query.

func (routeQuery) Delete

func (q routeQuery) Delete(o *Route, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Route record with an executor. Delete will match against the primary key column to find the record to delete.

func (routeQuery) DeleteAll

func (q routeQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (routeQuery) DeleteAllSlice

func (q routeQuery) DeleteAllSlice(o RouteSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (routeQuery) Domain

func (q routeQuery) Domain(o *Route, mods ...qm.QueryMod) domainQuery

Domain pointed to by the foreign key.

func (routeQuery) Exists

func (q routeQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (routeQuery) Insert

func (q routeQuery) Insert(o *Route, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (routeQuery) One

func (q routeQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Route, error)

One returns a single route record from the query.

func (routeQuery) Reload

func (q routeQuery) Reload(o *Route, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (routeQuery) ReloadAll

func (q routeQuery) ReloadAll(o *RouteSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (routeQuery) RemoveResourceRouteAnnotations

func (q routeQuery) RemoveResourceRouteAnnotations(o *Route, ctx context.Context, exec boil.ContextExecutor, related ...*RouteAnnotation) error

RemoveResourceRouteAnnotations relationships from objects passed in. Removes related items from R.ResourceRouteAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (routeQuery) RemoveResourceRouteLabels

func (q routeQuery) RemoveResourceRouteLabels(o *Route, ctx context.Context, exec boil.ContextExecutor, related ...*RouteLabel) error

RemoveResourceRouteLabels relationships from objects passed in. Removes related items from R.ResourceRouteLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (routeQuery) RemoveRouteBindings

func (q routeQuery) RemoveRouteBindings(o *Route, ctx context.Context, exec boil.ContextExecutor, related ...*RouteBinding) error

RemoveRouteBindings relationships from objects passed in. Removes related items from R.RouteBindings (uses pointer comparison\, removal does not keep order) Sets related.R.Route.

func (routeQuery) ResourceRouteAnnotations

func (q routeQuery) ResourceRouteAnnotations(o *Route, mods ...qm.QueryMod) routeAnnotationQuery

ResourceRouteAnnotations retrieves all the route_annotation's RouteAnnotations with an executor via resource_guid column.

func (routeQuery) ResourceRouteLabels

func (q routeQuery) ResourceRouteLabels(o *Route, mods ...qm.QueryMod) routeLabelQuery

ResourceRouteLabels retrieves all the route_label's RouteLabels with an executor via resource_guid column.

func (routeQuery) RouteBindings

func (q routeQuery) RouteBindings(o *Route, mods ...qm.QueryMod) routeBindingQuery

RouteBindings retrieves all the route_binding's RouteBindings with an executor.

func (routeQuery) RouteMappings

func (q routeQuery) RouteMappings(o *Route, mods ...qm.QueryMod) routeMappingQuery

RouteMappings retrieves all the route_mapping's RouteMappings with an executor.

func (routeQuery) SetDomain

func (q routeQuery) SetDomain(o *Route, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Domain) error

SetDomain of the route to the related item. Sets o.R.Domain to related. Adds o to related.R.Routes.

func (routeQuery) SetResourceRouteAnnotations

func (q routeQuery) SetResourceRouteAnnotations(o *Route, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteAnnotation) error

SetResourceRouteAnnotations removes all previously related items of the route replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceRouteAnnotations accordingly. Replaces o.R.ResourceRouteAnnotations with related. Sets related.R.Resource's ResourceRouteAnnotations accordingly.

func (routeQuery) SetResourceRouteLabels

func (q routeQuery) SetResourceRouteLabels(o *Route, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteLabel) error

SetResourceRouteLabels removes all previously related items of the route replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceRouteLabels accordingly. Replaces o.R.ResourceRouteLabels with related. Sets related.R.Resource's ResourceRouteLabels accordingly.

func (routeQuery) SetRouteBindings

func (q routeQuery) SetRouteBindings(o *Route, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteBinding) error

SetRouteBindings removes all previously related items of the route replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Route's RouteBindings accordingly. Replaces o.R.RouteBindings with related. Sets related.R.Route's RouteBindings accordingly.

func (routeQuery) SetSpace

func (q routeQuery) SetSpace(o *Route, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetSpace of the route to the related item. Sets o.R.Space to related. Adds o to related.R.Routes.

func (routeQuery) Space

func (q routeQuery) Space(o *Route, mods ...qm.QueryMod) spaceQuery

Space pointed to by the foreign key.

func (routeQuery) Update

func (q routeQuery) Update(o *Route, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Route. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (routeQuery) UpdateAll

func (q routeQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (routeQuery) UpdateAllSlice

func (q routeQuery) UpdateAllSlice(o RouteSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (routeQuery) Upsert

func (q routeQuery) Upsert(o *Route, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type routeR

routeR is where relationships are stored.

type routeR struct {
    Domain                   *Domain              `boil:"Domain" json:"Domain" toml:"Domain" yaml:"Domain"`
    Space                    *Space               `boil:"Space" json:"Space" toml:"Space" yaml:"Space"`
    ResourceRouteAnnotations RouteAnnotationSlice `boil:"ResourceRouteAnnotations" json:"ResourceRouteAnnotations" toml:"ResourceRouteAnnotations" yaml:"ResourceRouteAnnotations"`
    RouteBindings            RouteBindingSlice    `boil:"RouteBindings" json:"RouteBindings" toml:"RouteBindings" yaml:"RouteBindings"`
    ResourceRouteLabels      RouteLabelSlice      `boil:"ResourceRouteLabels" json:"ResourceRouteLabels" toml:"ResourceRouteLabels" yaml:"ResourceRouteLabels"`
    RouteMappings            RouteMappingSlice    `boil:"RouteMappings" json:"RouteMappings" toml:"RouteMappings" yaml:"RouteMappings"`
}

func (*routeR) NewStruct

func (*routeR) NewStruct() *routeR

NewStruct creates a new relationship struct

type schemaMigrationL

schemaMigrationL is where Load methods for each relationship are stored.

type schemaMigrationL struct{}

type schemaMigrationQuery

type schemaMigrationQuery struct {
    *queries.Query
}

func SchemaMigrations

func SchemaMigrations(mods ...qm.QueryMod) schemaMigrationQuery

SchemaMigrations retrieves all the records using an executor.

func (schemaMigrationQuery) All

func (q schemaMigrationQuery) All(ctx context.Context, exec boil.ContextExecutor) (SchemaMigrationSlice, error)

All returns all SchemaMigration records from the query.

func (schemaMigrationQuery) Count

func (q schemaMigrationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all SchemaMigration records in the query.

func (schemaMigrationQuery) Delete

func (q schemaMigrationQuery) Delete(o *SchemaMigration, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single SchemaMigration record with an executor. Delete will match against the primary key column to find the record to delete.

func (schemaMigrationQuery) DeleteAll

func (q schemaMigrationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (schemaMigrationQuery) DeleteAllSlice

func (q schemaMigrationQuery) DeleteAllSlice(o SchemaMigrationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (schemaMigrationQuery) Exists

func (q schemaMigrationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (schemaMigrationQuery) Insert

func (q schemaMigrationQuery) Insert(o *SchemaMigration, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (schemaMigrationQuery) One

func (q schemaMigrationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*SchemaMigration, error)

One returns a single schemaMigration record from the query.

func (schemaMigrationQuery) Reload

func (q schemaMigrationQuery) Reload(o *SchemaMigration, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (schemaMigrationQuery) ReloadAll

func (q schemaMigrationQuery) ReloadAll(o *SchemaMigrationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (schemaMigrationQuery) Update

func (q schemaMigrationQuery) Update(o *SchemaMigration, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the SchemaMigration. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (schemaMigrationQuery) UpdateAll

func (q schemaMigrationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (schemaMigrationQuery) UpdateAllSlice

func (q schemaMigrationQuery) UpdateAllSlice(o SchemaMigrationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (schemaMigrationQuery) Upsert

func (q schemaMigrationQuery) Upsert(o *SchemaMigration, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type schemaMigrationR

schemaMigrationR is where relationships are stored.

type schemaMigrationR struct {
}

func (*schemaMigrationR) NewStruct

func (*schemaMigrationR) NewStruct() *schemaMigrationR

NewStruct creates a new relationship struct

type securityGroupL

securityGroupL is where Load methods for each relationship are stored.

type securityGroupL struct{}

func (securityGroupL) LoadSecurityGroupsSpaces

func (securityGroupL) LoadSecurityGroupsSpaces(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSecurityGroup interface{}, mods queries.Applicator) error

LoadSecurityGroupsSpaces allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (securityGroupL) LoadStagingSecurityGroupStagingSecurityGroupsSpaces

func (securityGroupL) LoadStagingSecurityGroupStagingSecurityGroupsSpaces(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSecurityGroup interface{}, mods queries.Applicator) error

LoadStagingSecurityGroupStagingSecurityGroupsSpaces allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type securityGroupQuery

type securityGroupQuery struct {
    *queries.Query
}

func SecurityGroups

func SecurityGroups(mods ...qm.QueryMod) securityGroupQuery

SecurityGroups retrieves all the records using an executor.

func (securityGroupQuery) AddSecurityGroupsSpaces

func (q securityGroupQuery) AddSecurityGroupsSpaces(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SecurityGroupsSpace) error

AddSecurityGroupsSpaces adds the given related objects to the existing relationships of the security_group\, optionally inserting them as new records. Appends related to o.R.SecurityGroupsSpaces. Sets related.R.SecurityGroup appropriately.

func (securityGroupQuery) AddStagingSecurityGroupStagingSecurityGroupsSpaces

func (q securityGroupQuery) AddStagingSecurityGroupStagingSecurityGroupsSpaces(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*StagingSecurityGroupsSpace) error

AddStagingSecurityGroupStagingSecurityGroupsSpaces adds the given related objects to the existing relationships of the security_group\, optionally inserting them as new records. Appends related to o.R.StagingSecurityGroupStagingSecurityGroupsSpaces. Sets related.R.StagingSecurityGroup appropriately.

func (securityGroupQuery) All

func (q securityGroupQuery) All(ctx context.Context, exec boil.ContextExecutor) (SecurityGroupSlice, error)

All returns all SecurityGroup records from the query.

func (securityGroupQuery) Count

func (q securityGroupQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all SecurityGroup records in the query.

func (securityGroupQuery) Delete

func (q securityGroupQuery) Delete(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single SecurityGroup record with an executor. Delete will match against the primary key column to find the record to delete.

func (securityGroupQuery) DeleteAll

func (q securityGroupQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (securityGroupQuery) DeleteAllSlice

func (q securityGroupQuery) DeleteAllSlice(o SecurityGroupSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (securityGroupQuery) Exists

func (q securityGroupQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (securityGroupQuery) Insert

func (q securityGroupQuery) Insert(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (securityGroupQuery) One

func (q securityGroupQuery) One(ctx context.Context, exec boil.ContextExecutor) (*SecurityGroup, error)

One returns a single securityGroup record from the query.

func (securityGroupQuery) Reload

func (q securityGroupQuery) Reload(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (securityGroupQuery) ReloadAll

func (q securityGroupQuery) ReloadAll(o *SecurityGroupSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (securityGroupQuery) SecurityGroupsSpaces

func (q securityGroupQuery) SecurityGroupsSpaces(o *SecurityGroup, mods ...qm.QueryMod) securityGroupsSpaceQuery

SecurityGroupsSpaces retrieves all the security_groups_space's SecurityGroupsSpaces with an executor.

func (securityGroupQuery) StagingSecurityGroupStagingSecurityGroupsSpaces

func (q securityGroupQuery) StagingSecurityGroupStagingSecurityGroupsSpaces(o *SecurityGroup, mods ...qm.QueryMod) stagingSecurityGroupsSpaceQuery

StagingSecurityGroupStagingSecurityGroupsSpaces retrieves all the staging_security_groups_space's StagingSecurityGroupsSpaces with an executor via staging_security_group_id column.

func (securityGroupQuery) Update

func (q securityGroupQuery) Update(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the SecurityGroup. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (securityGroupQuery) UpdateAll

func (q securityGroupQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (securityGroupQuery) UpdateAllSlice

func (q securityGroupQuery) UpdateAllSlice(o SecurityGroupSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (securityGroupQuery) Upsert

func (q securityGroupQuery) Upsert(o *SecurityGroup, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type securityGroupR

securityGroupR is where relationships are stored.

type securityGroupR struct {
    SecurityGroupsSpaces                            SecurityGroupsSpaceSlice        `boil:"SecurityGroupsSpaces" json:"SecurityGroupsSpaces" toml:"SecurityGroupsSpaces" yaml:"SecurityGroupsSpaces"`
    StagingSecurityGroupStagingSecurityGroupsSpaces StagingSecurityGroupsSpaceSlice `boil:"StagingSecurityGroupStagingSecurityGroupsSpaces" json:"StagingSecurityGroupStagingSecurityGroupsSpaces" toml:"StagingSecurityGroupStagingSecurityGroupsSpaces" yaml:"StagingSecurityGroupStagingSecurityGroupsSpaces"`
}

func (*securityGroupR) NewStruct

func (*securityGroupR) NewStruct() *securityGroupR

NewStruct creates a new relationship struct

type securityGroupsSpaceL

securityGroupsSpaceL is where Load methods for each relationship are stored.

type securityGroupsSpaceL struct{}

func (securityGroupsSpaceL) LoadSecurityGroup

func (securityGroupsSpaceL) LoadSecurityGroup(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSecurityGroupsSpace interface{}, mods queries.Applicator) error

LoadSecurityGroup allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (securityGroupsSpaceL) LoadSpace

func (securityGroupsSpaceL) LoadSpace(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSecurityGroupsSpace interface{}, mods queries.Applicator) error

LoadSpace allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type securityGroupsSpaceQuery

type securityGroupsSpaceQuery struct {
    *queries.Query
}

func SecurityGroupsSpaces

func SecurityGroupsSpaces(mods ...qm.QueryMod) securityGroupsSpaceQuery

SecurityGroupsSpaces retrieves all the records using an executor.

func (securityGroupsSpaceQuery) All

func (q securityGroupsSpaceQuery) All(ctx context.Context, exec boil.ContextExecutor) (SecurityGroupsSpaceSlice, error)

All returns all SecurityGroupsSpace records from the query.

func (securityGroupsSpaceQuery) Count

func (q securityGroupsSpaceQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all SecurityGroupsSpace records in the query.

func (securityGroupsSpaceQuery) Delete

func (q securityGroupsSpaceQuery) Delete(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single SecurityGroupsSpace record with an executor. Delete will match against the primary key column to find the record to delete.

func (securityGroupsSpaceQuery) DeleteAll

func (q securityGroupsSpaceQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (securityGroupsSpaceQuery) DeleteAllSlice

func (q securityGroupsSpaceQuery) DeleteAllSlice(o SecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (securityGroupsSpaceQuery) Exists

func (q securityGroupsSpaceQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (securityGroupsSpaceQuery) Insert

func (q securityGroupsSpaceQuery) Insert(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (securityGroupsSpaceQuery) One

func (q securityGroupsSpaceQuery) One(ctx context.Context, exec boil.ContextExecutor) (*SecurityGroupsSpace, error)

One returns a single securityGroupsSpace record from the query.

func (securityGroupsSpaceQuery) Reload

func (q securityGroupsSpaceQuery) Reload(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (securityGroupsSpaceQuery) ReloadAll

func (q securityGroupsSpaceQuery) ReloadAll(o *SecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (securityGroupsSpaceQuery) SecurityGroup

func (q securityGroupsSpaceQuery) SecurityGroup(o *SecurityGroupsSpace, mods ...qm.QueryMod) securityGroupQuery

SecurityGroup pointed to by the foreign key.

func (securityGroupsSpaceQuery) SetSecurityGroup

func (q securityGroupsSpaceQuery) SetSecurityGroup(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, insert bool, related *SecurityGroup) error

SetSecurityGroup of the securityGroupsSpace to the related item. Sets o.R.SecurityGroup to related. Adds o to related.R.SecurityGroupsSpaces.

func (securityGroupsSpaceQuery) SetSpace

func (q securityGroupsSpaceQuery) SetSpace(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetSpace of the securityGroupsSpace to the related item. Sets o.R.Space to related. Adds o to related.R.SecurityGroupsSpaces.

func (securityGroupsSpaceQuery) Space

func (q securityGroupsSpaceQuery) Space(o *SecurityGroupsSpace, mods ...qm.QueryMod) spaceQuery

Space pointed to by the foreign key.

func (securityGroupsSpaceQuery) Update

func (q securityGroupsSpaceQuery) Update(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the SecurityGroupsSpace. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (securityGroupsSpaceQuery) UpdateAll

func (q securityGroupsSpaceQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (securityGroupsSpaceQuery) UpdateAllSlice

func (q securityGroupsSpaceQuery) UpdateAllSlice(o SecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (securityGroupsSpaceQuery) Upsert

func (q securityGroupsSpaceQuery) Upsert(o *SecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type securityGroupsSpaceR

securityGroupsSpaceR is where relationships are stored.

type securityGroupsSpaceR struct {
    SecurityGroup *SecurityGroup `boil:"SecurityGroup" json:"SecurityGroup" toml:"SecurityGroup" yaml:"SecurityGroup"`
    Space         *Space         `boil:"Space" json:"Space" toml:"Space" yaml:"Space"`
}

func (*securityGroupsSpaceR) NewStruct

func (*securityGroupsSpaceR) NewStruct() *securityGroupsSpaceR

NewStruct creates a new relationship struct

type serviceBindingAnnotationL

serviceBindingAnnotationL is where Load methods for each relationship are stored.

type serviceBindingAnnotationL struct{}

func (serviceBindingAnnotationL) LoadResource

func (serviceBindingAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBindingAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceBindingAnnotationQuery

type serviceBindingAnnotationQuery struct {
    *queries.Query
}

func ServiceBindingAnnotations

func ServiceBindingAnnotations(mods ...qm.QueryMod) serviceBindingAnnotationQuery

ServiceBindingAnnotations retrieves all the records using an executor.

func (serviceBindingAnnotationQuery) All

func (q serviceBindingAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceBindingAnnotationSlice, error)

All returns all ServiceBindingAnnotation records from the query.

func (serviceBindingAnnotationQuery) Count

func (q serviceBindingAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceBindingAnnotation records in the query.

func (serviceBindingAnnotationQuery) Delete

func (q serviceBindingAnnotationQuery) Delete(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceBindingAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceBindingAnnotationQuery) DeleteAll

func (q serviceBindingAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceBindingAnnotationQuery) DeleteAllSlice

func (q serviceBindingAnnotationQuery) DeleteAllSlice(o ServiceBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceBindingAnnotationQuery) Exists

func (q serviceBindingAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceBindingAnnotationQuery) Insert

func (q serviceBindingAnnotationQuery) Insert(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceBindingAnnotationQuery) One

func (q serviceBindingAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBindingAnnotation, error)

One returns a single serviceBindingAnnotation record from the query.

func (serviceBindingAnnotationQuery) Reload

func (q serviceBindingAnnotationQuery) Reload(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceBindingAnnotationQuery) ReloadAll

func (q serviceBindingAnnotationQuery) ReloadAll(o *ServiceBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceBindingAnnotationQuery) RemoveResource

func (q serviceBindingAnnotationQuery) RemoveResource(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, related *ServiceBinding) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceBindingAnnotationQuery) Resource

func (q serviceBindingAnnotationQuery) Resource(o *ServiceBindingAnnotation, mods ...qm.QueryMod) serviceBindingQuery

Resource pointed to by the foreign key.

func (serviceBindingAnnotationQuery) SetResource

func (q serviceBindingAnnotationQuery) SetResource(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceBinding) error

SetResource of the serviceBindingAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceBindingAnnotations.

func (serviceBindingAnnotationQuery) Update

func (q serviceBindingAnnotationQuery) Update(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceBindingAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceBindingAnnotationQuery) UpdateAll

func (q serviceBindingAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceBindingAnnotationQuery) UpdateAllSlice

func (q serviceBindingAnnotationQuery) UpdateAllSlice(o ServiceBindingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceBindingAnnotationQuery) Upsert

func (q serviceBindingAnnotationQuery) Upsert(o *ServiceBindingAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceBindingAnnotationR

serviceBindingAnnotationR is where relationships are stored.

type serviceBindingAnnotationR struct {
    Resource *ServiceBinding `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceBindingAnnotationR) NewStruct

func (*serviceBindingAnnotationR) NewStruct() *serviceBindingAnnotationR

NewStruct creates a new relationship struct

type serviceBindingL

serviceBindingL is where Load methods for each relationship are stored.

type serviceBindingL struct{}

func (serviceBindingL) LoadApp

func (serviceBindingL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBinding interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (serviceBindingL) LoadResourceServiceBindingAnnotations

func (serviceBindingL) LoadResourceServiceBindingAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBinding interface{}, mods queries.Applicator) error

LoadResourceServiceBindingAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceBindingL) LoadResourceServiceBindingLabels

func (serviceBindingL) LoadResourceServiceBindingLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBinding interface{}, mods queries.Applicator) error

LoadResourceServiceBindingLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceBindingL) LoadServiceBindingOperation

func (serviceBindingL) LoadServiceBindingOperation(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBinding interface{}, mods queries.Applicator) error

LoadServiceBindingOperation allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-1 relationship.

func (serviceBindingL) LoadServiceInstance

func (serviceBindingL) LoadServiceInstance(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBinding interface{}, mods queries.Applicator) error

LoadServiceInstance allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceBindingLabelL

serviceBindingLabelL is where Load methods for each relationship are stored.

type serviceBindingLabelL struct{}

func (serviceBindingLabelL) LoadResource

func (serviceBindingLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBindingLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceBindingLabelQuery

type serviceBindingLabelQuery struct {
    *queries.Query
}

func ServiceBindingLabels

func ServiceBindingLabels(mods ...qm.QueryMod) serviceBindingLabelQuery

ServiceBindingLabels retrieves all the records using an executor.

func (serviceBindingLabelQuery) All

func (q serviceBindingLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceBindingLabelSlice, error)

All returns all ServiceBindingLabel records from the query.

func (serviceBindingLabelQuery) Count

func (q serviceBindingLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceBindingLabel records in the query.

func (serviceBindingLabelQuery) Delete

func (q serviceBindingLabelQuery) Delete(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceBindingLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceBindingLabelQuery) DeleteAll

func (q serviceBindingLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceBindingLabelQuery) DeleteAllSlice

func (q serviceBindingLabelQuery) DeleteAllSlice(o ServiceBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceBindingLabelQuery) Exists

func (q serviceBindingLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceBindingLabelQuery) Insert

func (q serviceBindingLabelQuery) Insert(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceBindingLabelQuery) One

func (q serviceBindingLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBindingLabel, error)

One returns a single serviceBindingLabel record from the query.

func (serviceBindingLabelQuery) Reload

func (q serviceBindingLabelQuery) Reload(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceBindingLabelQuery) ReloadAll

func (q serviceBindingLabelQuery) ReloadAll(o *ServiceBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceBindingLabelQuery) RemoveResource

func (q serviceBindingLabelQuery) RemoveResource(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor, related *ServiceBinding) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceBindingLabelQuery) Resource

func (q serviceBindingLabelQuery) Resource(o *ServiceBindingLabel, mods ...qm.QueryMod) serviceBindingQuery

Resource pointed to by the foreign key.

func (serviceBindingLabelQuery) SetResource

func (q serviceBindingLabelQuery) SetResource(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceBinding) error

SetResource of the serviceBindingLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceBindingLabels.

func (serviceBindingLabelQuery) Update

func (q serviceBindingLabelQuery) Update(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceBindingLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceBindingLabelQuery) UpdateAll

func (q serviceBindingLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceBindingLabelQuery) UpdateAllSlice

func (q serviceBindingLabelQuery) UpdateAllSlice(o ServiceBindingLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceBindingLabelQuery) Upsert

func (q serviceBindingLabelQuery) Upsert(o *ServiceBindingLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceBindingLabelR

serviceBindingLabelR is where relationships are stored.

type serviceBindingLabelR struct {
    Resource *ServiceBinding `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceBindingLabelR) NewStruct

func (*serviceBindingLabelR) NewStruct() *serviceBindingLabelR

NewStruct creates a new relationship struct

type serviceBindingOperationL

serviceBindingOperationL is where Load methods for each relationship are stored.

type serviceBindingOperationL struct{}

func (serviceBindingOperationL) LoadServiceBinding

func (serviceBindingOperationL) LoadServiceBinding(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBindingOperation interface{}, mods queries.Applicator) error

LoadServiceBinding allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceBindingOperationQuery

type serviceBindingOperationQuery struct {
    *queries.Query
}

func ServiceBindingOperations

func ServiceBindingOperations(mods ...qm.QueryMod) serviceBindingOperationQuery

ServiceBindingOperations retrieves all the records using an executor.

func (serviceBindingOperationQuery) All

func (q serviceBindingOperationQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceBindingOperationSlice, error)

All returns all ServiceBindingOperation records from the query.

func (serviceBindingOperationQuery) Count

func (q serviceBindingOperationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceBindingOperation records in the query.

func (serviceBindingOperationQuery) Delete

func (q serviceBindingOperationQuery) Delete(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceBindingOperation record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceBindingOperationQuery) DeleteAll

func (q serviceBindingOperationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceBindingOperationQuery) DeleteAllSlice

func (q serviceBindingOperationQuery) DeleteAllSlice(o ServiceBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceBindingOperationQuery) Exists

func (q serviceBindingOperationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceBindingOperationQuery) Insert

func (q serviceBindingOperationQuery) Insert(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceBindingOperationQuery) One

func (q serviceBindingOperationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBindingOperation, error)

One returns a single serviceBindingOperation record from the query.

func (serviceBindingOperationQuery) Reload

func (q serviceBindingOperationQuery) Reload(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceBindingOperationQuery) ReloadAll

func (q serviceBindingOperationQuery) ReloadAll(o *ServiceBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceBindingOperationQuery) RemoveServiceBinding

func (q serviceBindingOperationQuery) RemoveServiceBinding(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor, related *ServiceBinding) error

RemoveServiceBinding relationship. Sets o.R.ServiceBinding to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceBindingOperationQuery) ServiceBinding

func (q serviceBindingOperationQuery) ServiceBinding(o *ServiceBindingOperation, mods ...qm.QueryMod) serviceBindingQuery

ServiceBinding pointed to by the foreign key.

func (serviceBindingOperationQuery) SetServiceBinding

func (q serviceBindingOperationQuery) SetServiceBinding(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceBinding) error

SetServiceBinding of the serviceBindingOperation to the related item. Sets o.R.ServiceBinding to related. Adds o to related.R.ServiceBindingOperation.

func (serviceBindingOperationQuery) Update

func (q serviceBindingOperationQuery) Update(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceBindingOperation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceBindingOperationQuery) UpdateAll

func (q serviceBindingOperationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceBindingOperationQuery) UpdateAllSlice

func (q serviceBindingOperationQuery) UpdateAllSlice(o ServiceBindingOperationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceBindingOperationQuery) Upsert

func (q serviceBindingOperationQuery) Upsert(o *ServiceBindingOperation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceBindingOperationR

serviceBindingOperationR is where relationships are stored.

type serviceBindingOperationR struct {
    ServiceBinding *ServiceBinding `boil:"ServiceBinding" json:"ServiceBinding" toml:"ServiceBinding" yaml:"ServiceBinding"`
}

func (*serviceBindingOperationR) NewStruct

func (*serviceBindingOperationR) NewStruct() *serviceBindingOperationR

NewStruct creates a new relationship struct

type serviceBindingQuery

type serviceBindingQuery struct {
    *queries.Query
}

func ServiceBindings

func ServiceBindings(mods ...qm.QueryMod) serviceBindingQuery

ServiceBindings retrieves all the records using an executor.

func (serviceBindingQuery) AddResourceServiceBindingAnnotations

func (q serviceBindingQuery) AddResourceServiceBindingAnnotations(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBindingAnnotation) error

AddResourceServiceBindingAnnotations adds the given related objects to the existing relationships of the service_binding\, optionally inserting them as new records. Appends related to o.R.ResourceServiceBindingAnnotations. Sets related.R.Resource appropriately.

func (serviceBindingQuery) AddResourceServiceBindingLabels

func (q serviceBindingQuery) AddResourceServiceBindingLabels(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBindingLabel) error

AddResourceServiceBindingLabels adds the given related objects to the existing relationships of the service_binding\, optionally inserting them as new records. Appends related to o.R.ResourceServiceBindingLabels. Sets related.R.Resource appropriately.

func (serviceBindingQuery) All

func (q serviceBindingQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceBindingSlice, error)

All returns all ServiceBinding records from the query.

func (serviceBindingQuery) App

func (q serviceBindingQuery) App(o *ServiceBinding, mods ...qm.QueryMod) appQuery

App pointed to by the foreign key.

func (serviceBindingQuery) Count

func (q serviceBindingQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceBinding records in the query.

func (serviceBindingQuery) Delete

func (q serviceBindingQuery) Delete(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceBinding record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceBindingQuery) DeleteAll

func (q serviceBindingQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceBindingQuery) DeleteAllSlice

func (q serviceBindingQuery) DeleteAllSlice(o ServiceBindingSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceBindingQuery) Exists

func (q serviceBindingQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceBindingQuery) Insert

func (q serviceBindingQuery) Insert(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceBindingQuery) One

func (q serviceBindingQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBinding, error)

One returns a single serviceBinding record from the query.

func (serviceBindingQuery) Reload

func (q serviceBindingQuery) Reload(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceBindingQuery) ReloadAll

func (q serviceBindingQuery) ReloadAll(o *ServiceBindingSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceBindingQuery) RemoveResourceServiceBindingAnnotations

func (q serviceBindingQuery) RemoveResourceServiceBindingAnnotations(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceBindingAnnotation) error

RemoveResourceServiceBindingAnnotations relationships from objects passed in. Removes related items from R.ResourceServiceBindingAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceBindingQuery) RemoveResourceServiceBindingLabels

func (q serviceBindingQuery) RemoveResourceServiceBindingLabels(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceBindingLabel) error

RemoveResourceServiceBindingLabels relationships from objects passed in. Removes related items from R.ResourceServiceBindingLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceBindingQuery) RemoveServiceBindingOperation

func (q serviceBindingQuery) RemoveServiceBindingOperation(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, related *ServiceBindingOperation) error

RemoveServiceBindingOperation relationship. Sets o.R.ServiceBindingOperation to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceBindingQuery) ResourceServiceBindingAnnotations

func (q serviceBindingQuery) ResourceServiceBindingAnnotations(o *ServiceBinding, mods ...qm.QueryMod) serviceBindingAnnotationQuery

ResourceServiceBindingAnnotations retrieves all the service_binding_annotation's ServiceBindingAnnotations with an executor via resource_guid column.

func (serviceBindingQuery) ResourceServiceBindingLabels

func (q serviceBindingQuery) ResourceServiceBindingLabels(o *ServiceBinding, mods ...qm.QueryMod) serviceBindingLabelQuery

ResourceServiceBindingLabels retrieves all the service_binding_label's ServiceBindingLabels with an executor via resource_guid column.

func (serviceBindingQuery) ServiceBindingOperation

func (q serviceBindingQuery) ServiceBindingOperation(o *ServiceBinding, mods ...qm.QueryMod) serviceBindingOperationQuery

ServiceBindingOperation pointed to by the foreign key.

func (serviceBindingQuery) ServiceInstance

func (q serviceBindingQuery) ServiceInstance(o *ServiceBinding, mods ...qm.QueryMod) serviceInstanceQuery

ServiceInstance pointed to by the foreign key.

func (serviceBindingQuery) SetApp

func (q serviceBindingQuery) SetApp(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetApp of the serviceBinding to the related item. Sets o.R.App to related. Adds o to related.R.ServiceBindings.

func (serviceBindingQuery) SetResourceServiceBindingAnnotations

func (q serviceBindingQuery) SetResourceServiceBindingAnnotations(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBindingAnnotation) error

SetResourceServiceBindingAnnotations removes all previously related items of the service_binding replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceBindingAnnotations accordingly. Replaces o.R.ResourceServiceBindingAnnotations with related. Sets related.R.Resource's ResourceServiceBindingAnnotations accordingly.

func (serviceBindingQuery) SetResourceServiceBindingLabels

func (q serviceBindingQuery) SetResourceServiceBindingLabels(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBindingLabel) error

SetResourceServiceBindingLabels removes all previously related items of the service_binding replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceBindingLabels accordingly. Replaces o.R.ResourceServiceBindingLabels with related. Sets related.R.Resource's ResourceServiceBindingLabels accordingly.

func (serviceBindingQuery) SetServiceBindingOperation

func (q serviceBindingQuery) SetServiceBindingOperation(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceBindingOperation) error

SetServiceBindingOperation of the serviceBinding to the related item. Sets o.R.ServiceBindingOperation to related. Adds o to related.R.ServiceBinding.

func (serviceBindingQuery) SetServiceInstance

func (q serviceBindingQuery) SetServiceInstance(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceInstance) error

SetServiceInstance of the serviceBinding to the related item. Sets o.R.ServiceInstance to related. Adds o to related.R.ServiceBindings.

func (serviceBindingQuery) Update

func (q serviceBindingQuery) Update(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceBinding. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceBindingQuery) UpdateAll

func (q serviceBindingQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceBindingQuery) UpdateAllSlice

func (q serviceBindingQuery) UpdateAllSlice(o ServiceBindingSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceBindingQuery) Upsert

func (q serviceBindingQuery) Upsert(o *ServiceBinding, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceBindingR

serviceBindingR is where relationships are stored.

type serviceBindingR struct {
    App                               *App                          `boil:"App" json:"App" toml:"App" yaml:"App"`
    ServiceInstance                   *ServiceInstance              `boil:"ServiceInstance" json:"ServiceInstance" toml:"ServiceInstance" yaml:"ServiceInstance"`
    ServiceBindingOperation           *ServiceBindingOperation      `boil:"ServiceBindingOperation" json:"ServiceBindingOperation" toml:"ServiceBindingOperation" yaml:"ServiceBindingOperation"`
    ResourceServiceBindingAnnotations ServiceBindingAnnotationSlice `boil:"ResourceServiceBindingAnnotations" json:"ResourceServiceBindingAnnotations" toml:"ResourceServiceBindingAnnotations" yaml:"ResourceServiceBindingAnnotations"`
    ResourceServiceBindingLabels      ServiceBindingLabelSlice      `boil:"ResourceServiceBindingLabels" json:"ResourceServiceBindingLabels" toml:"ResourceServiceBindingLabels" yaml:"ResourceServiceBindingLabels"`
}

func (*serviceBindingR) NewStruct

func (*serviceBindingR) NewStruct() *serviceBindingR

NewStruct creates a new relationship struct

type serviceBrokerAnnotationL

serviceBrokerAnnotationL is where Load methods for each relationship are stored.

type serviceBrokerAnnotationL struct{}

func (serviceBrokerAnnotationL) LoadResource

func (serviceBrokerAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBrokerAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceBrokerAnnotationQuery

type serviceBrokerAnnotationQuery struct {
    *queries.Query
}

func ServiceBrokerAnnotations

func ServiceBrokerAnnotations(mods ...qm.QueryMod) serviceBrokerAnnotationQuery

ServiceBrokerAnnotations retrieves all the records using an executor.

func (serviceBrokerAnnotationQuery) All

func (q serviceBrokerAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerAnnotationSlice, error)

All returns all ServiceBrokerAnnotation records from the query.

func (serviceBrokerAnnotationQuery) Count

func (q serviceBrokerAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceBrokerAnnotation records in the query.

func (serviceBrokerAnnotationQuery) Delete

func (q serviceBrokerAnnotationQuery) Delete(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceBrokerAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceBrokerAnnotationQuery) DeleteAll

func (q serviceBrokerAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceBrokerAnnotationQuery) DeleteAllSlice

func (q serviceBrokerAnnotationQuery) DeleteAllSlice(o ServiceBrokerAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceBrokerAnnotationQuery) Exists

func (q serviceBrokerAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceBrokerAnnotationQuery) Insert

func (q serviceBrokerAnnotationQuery) Insert(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceBrokerAnnotationQuery) One

func (q serviceBrokerAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBrokerAnnotation, error)

One returns a single serviceBrokerAnnotation record from the query.

func (serviceBrokerAnnotationQuery) Reload

func (q serviceBrokerAnnotationQuery) Reload(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceBrokerAnnotationQuery) ReloadAll

func (q serviceBrokerAnnotationQuery) ReloadAll(o *ServiceBrokerAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceBrokerAnnotationQuery) RemoveResource

func (q serviceBrokerAnnotationQuery) RemoveResource(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor, related *ServiceBroker) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceBrokerAnnotationQuery) Resource

func (q serviceBrokerAnnotationQuery) Resource(o *ServiceBrokerAnnotation, mods ...qm.QueryMod) serviceBrokerQuery

Resource pointed to by the foreign key.

func (serviceBrokerAnnotationQuery) SetResource

func (q serviceBrokerAnnotationQuery) SetResource(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceBroker) error

SetResource of the serviceBrokerAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceBrokerAnnotations.

func (serviceBrokerAnnotationQuery) Update

func (q serviceBrokerAnnotationQuery) Update(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceBrokerAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceBrokerAnnotationQuery) UpdateAll

func (q serviceBrokerAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceBrokerAnnotationQuery) UpdateAllSlice

func (q serviceBrokerAnnotationQuery) UpdateAllSlice(o ServiceBrokerAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceBrokerAnnotationQuery) Upsert

func (q serviceBrokerAnnotationQuery) Upsert(o *ServiceBrokerAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceBrokerAnnotationR

serviceBrokerAnnotationR is where relationships are stored.

type serviceBrokerAnnotationR struct {
    Resource *ServiceBroker `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceBrokerAnnotationR) NewStruct

func (*serviceBrokerAnnotationR) NewStruct() *serviceBrokerAnnotationR

NewStruct creates a new relationship struct

type serviceBrokerL

serviceBrokerL is where Load methods for each relationship are stored.

type serviceBrokerL struct{}

func (serviceBrokerL) LoadFKServiceBrokerServiceBrokerUpdateRequests

func (serviceBrokerL) LoadFKServiceBrokerServiceBrokerUpdateRequests(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBroker interface{}, mods queries.Applicator) error

LoadFKServiceBrokerServiceBrokerUpdateRequests allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceBrokerL) LoadResourceServiceBrokerAnnotations

func (serviceBrokerL) LoadResourceServiceBrokerAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBroker interface{}, mods queries.Applicator) error

LoadResourceServiceBrokerAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceBrokerL) LoadResourceServiceBrokerLabels

func (serviceBrokerL) LoadResourceServiceBrokerLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBroker interface{}, mods queries.Applicator) error

LoadResourceServiceBrokerLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceBrokerL) LoadServices

func (serviceBrokerL) LoadServices(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBroker interface{}, mods queries.Applicator) error

LoadServices allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceBrokerL) LoadSpace

func (serviceBrokerL) LoadSpace(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBroker interface{}, mods queries.Applicator) error

LoadSpace allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceBrokerLabelL

serviceBrokerLabelL is where Load methods for each relationship are stored.

type serviceBrokerLabelL struct{}

func (serviceBrokerLabelL) LoadResource

func (serviceBrokerLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBrokerLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceBrokerLabelQuery

type serviceBrokerLabelQuery struct {
    *queries.Query
}

func ServiceBrokerLabels

func ServiceBrokerLabels(mods ...qm.QueryMod) serviceBrokerLabelQuery

ServiceBrokerLabels retrieves all the records using an executor.

func (serviceBrokerLabelQuery) All

func (q serviceBrokerLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerLabelSlice, error)

All returns all ServiceBrokerLabel records from the query.

func (serviceBrokerLabelQuery) Count

func (q serviceBrokerLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceBrokerLabel records in the query.

func (serviceBrokerLabelQuery) Delete

func (q serviceBrokerLabelQuery) Delete(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceBrokerLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceBrokerLabelQuery) DeleteAll

func (q serviceBrokerLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceBrokerLabelQuery) DeleteAllSlice

func (q serviceBrokerLabelQuery) DeleteAllSlice(o ServiceBrokerLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceBrokerLabelQuery) Exists

func (q serviceBrokerLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceBrokerLabelQuery) Insert

func (q serviceBrokerLabelQuery) Insert(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceBrokerLabelQuery) One

func (q serviceBrokerLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBrokerLabel, error)

One returns a single serviceBrokerLabel record from the query.

func (serviceBrokerLabelQuery) Reload

func (q serviceBrokerLabelQuery) Reload(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceBrokerLabelQuery) ReloadAll

func (q serviceBrokerLabelQuery) ReloadAll(o *ServiceBrokerLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceBrokerLabelQuery) RemoveResource

func (q serviceBrokerLabelQuery) RemoveResource(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor, related *ServiceBroker) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceBrokerLabelQuery) Resource

func (q serviceBrokerLabelQuery) Resource(o *ServiceBrokerLabel, mods ...qm.QueryMod) serviceBrokerQuery

Resource pointed to by the foreign key.

func (serviceBrokerLabelQuery) SetResource

func (q serviceBrokerLabelQuery) SetResource(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceBroker) error

SetResource of the serviceBrokerLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceBrokerLabels.

func (serviceBrokerLabelQuery) Update

func (q serviceBrokerLabelQuery) Update(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceBrokerLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceBrokerLabelQuery) UpdateAll

func (q serviceBrokerLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceBrokerLabelQuery) UpdateAllSlice

func (q serviceBrokerLabelQuery) UpdateAllSlice(o ServiceBrokerLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceBrokerLabelQuery) Upsert

func (q serviceBrokerLabelQuery) Upsert(o *ServiceBrokerLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceBrokerLabelR

serviceBrokerLabelR is where relationships are stored.

type serviceBrokerLabelR struct {
    Resource *ServiceBroker `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceBrokerLabelR) NewStruct

func (*serviceBrokerLabelR) NewStruct() *serviceBrokerLabelR

NewStruct creates a new relationship struct

type serviceBrokerQuery

type serviceBrokerQuery struct {
    *queries.Query
}

func ServiceBrokers

func ServiceBrokers(mods ...qm.QueryMod) serviceBrokerQuery

ServiceBrokers retrieves all the records using an executor.

func (serviceBrokerQuery) AddFKServiceBrokerServiceBrokerUpdateRequests

func (q serviceBrokerQuery) AddFKServiceBrokerServiceBrokerUpdateRequests(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBrokerUpdateRequest) error

AddFKServiceBrokerServiceBrokerUpdateRequests adds the given related objects to the existing relationships of the service_broker\, optionally inserting them as new records. Appends related to o.R.FKServiceBrokerServiceBrokerUpdateRequests. Sets related.R.FKServiceBroker appropriately.

func (serviceBrokerQuery) AddResourceServiceBrokerAnnotations

func (q serviceBrokerQuery) AddResourceServiceBrokerAnnotations(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBrokerAnnotation) error

AddResourceServiceBrokerAnnotations adds the given related objects to the existing relationships of the service_broker\, optionally inserting them as new records. Appends related to o.R.ResourceServiceBrokerAnnotations. Sets related.R.Resource appropriately.

func (serviceBrokerQuery) AddResourceServiceBrokerLabels

func (q serviceBrokerQuery) AddResourceServiceBrokerLabels(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBrokerLabel) error

AddResourceServiceBrokerLabels adds the given related objects to the existing relationships of the service_broker\, optionally inserting them as new records. Appends related to o.R.ResourceServiceBrokerLabels. Sets related.R.Resource appropriately.

func (serviceBrokerQuery) AddServices

func (q serviceBrokerQuery) AddServices(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Service) error

AddServices adds the given related objects to the existing relationships of the service_broker\, optionally inserting them as new records. Appends related to o.R.Services. Sets related.R.ServiceBroker appropriately.

func (serviceBrokerQuery) All

func (q serviceBrokerQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerSlice, error)

All returns all ServiceBroker records from the query.

func (serviceBrokerQuery) Count

func (q serviceBrokerQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceBroker records in the query.

func (serviceBrokerQuery) Delete

func (q serviceBrokerQuery) Delete(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceBroker record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceBrokerQuery) DeleteAll

func (q serviceBrokerQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceBrokerQuery) DeleteAllSlice

func (q serviceBrokerQuery) DeleteAllSlice(o ServiceBrokerSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceBrokerQuery) Exists

func (q serviceBrokerQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceBrokerQuery) FKServiceBrokerServiceBrokerUpdateRequests

func (q serviceBrokerQuery) FKServiceBrokerServiceBrokerUpdateRequests(o *ServiceBroker, mods ...qm.QueryMod) serviceBrokerUpdateRequestQuery

FKServiceBrokerServiceBrokerUpdateRequests retrieves all the service_broker_update_request's ServiceBrokerUpdateRequests with an executor via fk_service_brokers_id column.

func (serviceBrokerQuery) Insert

func (q serviceBrokerQuery) Insert(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceBrokerQuery) One

func (q serviceBrokerQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBroker, error)

One returns a single serviceBroker record from the query.

func (serviceBrokerQuery) Reload

func (q serviceBrokerQuery) Reload(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceBrokerQuery) ReloadAll

func (q serviceBrokerQuery) ReloadAll(o *ServiceBrokerSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceBrokerQuery) RemoveFKServiceBrokerServiceBrokerUpdateRequests

func (q serviceBrokerQuery) RemoveFKServiceBrokerServiceBrokerUpdateRequests(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceBrokerUpdateRequest) error

RemoveFKServiceBrokerServiceBrokerUpdateRequests relationships from objects passed in. Removes related items from R.FKServiceBrokerServiceBrokerUpdateRequests (uses pointer comparison\, removal does not keep order) Sets related.R.FKServiceBroker.

func (serviceBrokerQuery) RemoveResourceServiceBrokerAnnotations

func (q serviceBrokerQuery) RemoveResourceServiceBrokerAnnotations(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceBrokerAnnotation) error

RemoveResourceServiceBrokerAnnotations relationships from objects passed in. Removes related items from R.ResourceServiceBrokerAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceBrokerQuery) RemoveResourceServiceBrokerLabels

func (q serviceBrokerQuery) RemoveResourceServiceBrokerLabels(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceBrokerLabel) error

RemoveResourceServiceBrokerLabels relationships from objects passed in. Removes related items from R.ResourceServiceBrokerLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceBrokerQuery) RemoveServices

func (q serviceBrokerQuery) RemoveServices(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, related ...*Service) error

RemoveServices relationships from objects passed in. Removes related items from R.Services (uses pointer comparison\, removal does not keep order) Sets related.R.ServiceBroker.

func (serviceBrokerQuery) RemoveSpace

func (q serviceBrokerQuery) RemoveSpace(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, related *Space) error

RemoveSpace relationship. Sets o.R.Space to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceBrokerQuery) ResourceServiceBrokerAnnotations

func (q serviceBrokerQuery) ResourceServiceBrokerAnnotations(o *ServiceBroker, mods ...qm.QueryMod) serviceBrokerAnnotationQuery

ResourceServiceBrokerAnnotations retrieves all the service_broker_annotation's ServiceBrokerAnnotations with an executor via resource_guid column.

func (serviceBrokerQuery) ResourceServiceBrokerLabels

func (q serviceBrokerQuery) ResourceServiceBrokerLabels(o *ServiceBroker, mods ...qm.QueryMod) serviceBrokerLabelQuery

ResourceServiceBrokerLabels retrieves all the service_broker_label's ServiceBrokerLabels with an executor via resource_guid column.

func (serviceBrokerQuery) Services

func (q serviceBrokerQuery) Services(o *ServiceBroker, mods ...qm.QueryMod) serviceQuery

Services retrieves all the service's Services with an executor.

func (serviceBrokerQuery) SetFKServiceBrokerServiceBrokerUpdateRequests

func (q serviceBrokerQuery) SetFKServiceBrokerServiceBrokerUpdateRequests(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBrokerUpdateRequest) error

SetFKServiceBrokerServiceBrokerUpdateRequests removes all previously related items of the service_broker replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.FKServiceBroker's FKServiceBrokerServiceBrokerUpdateRequests accordingly. Replaces o.R.FKServiceBrokerServiceBrokerUpdateRequests with related. Sets related.R.FKServiceBroker's FKServiceBrokerServiceBrokerUpdateRequests accordingly.

func (serviceBrokerQuery) SetResourceServiceBrokerAnnotations

func (q serviceBrokerQuery) SetResourceServiceBrokerAnnotations(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBrokerAnnotation) error

SetResourceServiceBrokerAnnotations removes all previously related items of the service_broker replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceBrokerAnnotations accordingly. Replaces o.R.ResourceServiceBrokerAnnotations with related. Sets related.R.Resource's ResourceServiceBrokerAnnotations accordingly.

func (serviceBrokerQuery) SetResourceServiceBrokerLabels

func (q serviceBrokerQuery) SetResourceServiceBrokerLabels(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBrokerLabel) error

SetResourceServiceBrokerLabels removes all previously related items of the service_broker replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceBrokerLabels accordingly. Replaces o.R.ResourceServiceBrokerLabels with related. Sets related.R.Resource's ResourceServiceBrokerLabels accordingly.

func (serviceBrokerQuery) SetServices

func (q serviceBrokerQuery) SetServices(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Service) error

SetServices removes all previously related items of the service_broker replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.ServiceBroker's Services accordingly. Replaces o.R.Services with related. Sets related.R.ServiceBroker's Services accordingly.

func (serviceBrokerQuery) SetSpace

func (q serviceBrokerQuery) SetSpace(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetSpace of the serviceBroker to the related item. Sets o.R.Space to related. Adds o to related.R.ServiceBrokers.

func (serviceBrokerQuery) Space

func (q serviceBrokerQuery) Space(o *ServiceBroker, mods ...qm.QueryMod) spaceQuery

Space pointed to by the foreign key.

func (serviceBrokerQuery) Update

func (q serviceBrokerQuery) Update(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceBroker. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceBrokerQuery) UpdateAll

func (q serviceBrokerQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceBrokerQuery) UpdateAllSlice

func (q serviceBrokerQuery) UpdateAllSlice(o ServiceBrokerSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceBrokerQuery) Upsert

func (q serviceBrokerQuery) Upsert(o *ServiceBroker, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceBrokerR

serviceBrokerR is where relationships are stored.

type serviceBrokerR struct {
    Space                                      *Space                          `boil:"Space" json:"Space" toml:"Space" yaml:"Space"`
    ResourceServiceBrokerAnnotations           ServiceBrokerAnnotationSlice    `boil:"ResourceServiceBrokerAnnotations" json:"ResourceServiceBrokerAnnotations" toml:"ResourceServiceBrokerAnnotations" yaml:"ResourceServiceBrokerAnnotations"`
    ResourceServiceBrokerLabels                ServiceBrokerLabelSlice         `boil:"ResourceServiceBrokerLabels" json:"ResourceServiceBrokerLabels" toml:"ResourceServiceBrokerLabels" yaml:"ResourceServiceBrokerLabels"`
    FKServiceBrokerServiceBrokerUpdateRequests ServiceBrokerUpdateRequestSlice `boil:"FKServiceBrokerServiceBrokerUpdateRequests" json:"FKServiceBrokerServiceBrokerUpdateRequests" toml:"FKServiceBrokerServiceBrokerUpdateRequests" yaml:"FKServiceBrokerServiceBrokerUpdateRequests"`
    Services                                   ServiceSlice                    `boil:"Services" json:"Services" toml:"Services" yaml:"Services"`
}

func (*serviceBrokerR) NewStruct

func (*serviceBrokerR) NewStruct() *serviceBrokerR

NewStruct creates a new relationship struct

type serviceBrokerUpdateRequestAnnotationL

serviceBrokerUpdateRequestAnnotationL is where Load methods for each relationship are stored.

type serviceBrokerUpdateRequestAnnotationL struct{}

func (serviceBrokerUpdateRequestAnnotationL) LoadResource

func (serviceBrokerUpdateRequestAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBrokerUpdateRequestAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceBrokerUpdateRequestAnnotationQuery

type serviceBrokerUpdateRequestAnnotationQuery struct {
    *queries.Query
}

func ServiceBrokerUpdateRequestAnnotations

func ServiceBrokerUpdateRequestAnnotations(mods ...qm.QueryMod) serviceBrokerUpdateRequestAnnotationQuery

ServiceBrokerUpdateRequestAnnotations retrieves all the records using an executor.

func (serviceBrokerUpdateRequestAnnotationQuery) All

func (q serviceBrokerUpdateRequestAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerUpdateRequestAnnotationSlice, error)

All returns all ServiceBrokerUpdateRequestAnnotation records from the query.

func (serviceBrokerUpdateRequestAnnotationQuery) Count

func (q serviceBrokerUpdateRequestAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceBrokerUpdateRequestAnnotation records in the query.

func (serviceBrokerUpdateRequestAnnotationQuery) Delete

func (q serviceBrokerUpdateRequestAnnotationQuery) Delete(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceBrokerUpdateRequestAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceBrokerUpdateRequestAnnotationQuery) DeleteAll

func (q serviceBrokerUpdateRequestAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceBrokerUpdateRequestAnnotationQuery) DeleteAllSlice

func (q serviceBrokerUpdateRequestAnnotationQuery) DeleteAllSlice(o ServiceBrokerUpdateRequestAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceBrokerUpdateRequestAnnotationQuery) Exists

func (q serviceBrokerUpdateRequestAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceBrokerUpdateRequestAnnotationQuery) Insert

func (q serviceBrokerUpdateRequestAnnotationQuery) Insert(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceBrokerUpdateRequestAnnotationQuery) One

func (q serviceBrokerUpdateRequestAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBrokerUpdateRequestAnnotation, error)

One returns a single serviceBrokerUpdateRequestAnnotation record from the query.

func (serviceBrokerUpdateRequestAnnotationQuery) Reload

func (q serviceBrokerUpdateRequestAnnotationQuery) Reload(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceBrokerUpdateRequestAnnotationQuery) ReloadAll

func (q serviceBrokerUpdateRequestAnnotationQuery) ReloadAll(o *ServiceBrokerUpdateRequestAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceBrokerUpdateRequestAnnotationQuery) RemoveResource

func (q serviceBrokerUpdateRequestAnnotationQuery) RemoveResource(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor, related *ServiceBrokerUpdateRequest) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceBrokerUpdateRequestAnnotationQuery) Resource

func (q serviceBrokerUpdateRequestAnnotationQuery) Resource(o *ServiceBrokerUpdateRequestAnnotation, mods ...qm.QueryMod) serviceBrokerUpdateRequestQuery

Resource pointed to by the foreign key.

func (serviceBrokerUpdateRequestAnnotationQuery) SetResource

func (q serviceBrokerUpdateRequestAnnotationQuery) SetResource(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceBrokerUpdateRequest) error

SetResource of the serviceBrokerUpdateRequestAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceBrokerUpdateRequestAnnotations.

func (serviceBrokerUpdateRequestAnnotationQuery) Update

func (q serviceBrokerUpdateRequestAnnotationQuery) Update(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceBrokerUpdateRequestAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceBrokerUpdateRequestAnnotationQuery) UpdateAll

func (q serviceBrokerUpdateRequestAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceBrokerUpdateRequestAnnotationQuery) UpdateAllSlice

func (q serviceBrokerUpdateRequestAnnotationQuery) UpdateAllSlice(o ServiceBrokerUpdateRequestAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceBrokerUpdateRequestAnnotationQuery) Upsert

func (q serviceBrokerUpdateRequestAnnotationQuery) Upsert(o *ServiceBrokerUpdateRequestAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceBrokerUpdateRequestAnnotationR

serviceBrokerUpdateRequestAnnotationR is where relationships are stored.

type serviceBrokerUpdateRequestAnnotationR struct {
    Resource *ServiceBrokerUpdateRequest `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceBrokerUpdateRequestAnnotationR) NewStruct

func (*serviceBrokerUpdateRequestAnnotationR) NewStruct() *serviceBrokerUpdateRequestAnnotationR

NewStruct creates a new relationship struct

type serviceBrokerUpdateRequestL

serviceBrokerUpdateRequestL is where Load methods for each relationship are stored.

type serviceBrokerUpdateRequestL struct{}

func (serviceBrokerUpdateRequestL) LoadFKServiceBroker

func (serviceBrokerUpdateRequestL) LoadFKServiceBroker(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBrokerUpdateRequest interface{}, mods queries.Applicator) error

LoadFKServiceBroker allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (serviceBrokerUpdateRequestL) LoadResourceServiceBrokerUpdateRequestAnnotations

func (serviceBrokerUpdateRequestL) LoadResourceServiceBrokerUpdateRequestAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBrokerUpdateRequest interface{}, mods queries.Applicator) error

LoadResourceServiceBrokerUpdateRequestAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceBrokerUpdateRequestL) LoadResourceServiceBrokerUpdateRequestLabels

func (serviceBrokerUpdateRequestL) LoadResourceServiceBrokerUpdateRequestLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBrokerUpdateRequest interface{}, mods queries.Applicator) error

LoadResourceServiceBrokerUpdateRequestLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type serviceBrokerUpdateRequestLabelL

serviceBrokerUpdateRequestLabelL is where Load methods for each relationship are stored.

type serviceBrokerUpdateRequestLabelL struct{}

func (serviceBrokerUpdateRequestLabelL) LoadResource

func (serviceBrokerUpdateRequestLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceBrokerUpdateRequestLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceBrokerUpdateRequestLabelQuery

type serviceBrokerUpdateRequestLabelQuery struct {
    *queries.Query
}

func ServiceBrokerUpdateRequestLabels

func ServiceBrokerUpdateRequestLabels(mods ...qm.QueryMod) serviceBrokerUpdateRequestLabelQuery

ServiceBrokerUpdateRequestLabels retrieves all the records using an executor.

func (serviceBrokerUpdateRequestLabelQuery) All

func (q serviceBrokerUpdateRequestLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerUpdateRequestLabelSlice, error)

All returns all ServiceBrokerUpdateRequestLabel records from the query.

func (serviceBrokerUpdateRequestLabelQuery) Count

func (q serviceBrokerUpdateRequestLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceBrokerUpdateRequestLabel records in the query.

func (serviceBrokerUpdateRequestLabelQuery) Delete

func (q serviceBrokerUpdateRequestLabelQuery) Delete(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceBrokerUpdateRequestLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceBrokerUpdateRequestLabelQuery) DeleteAll

func (q serviceBrokerUpdateRequestLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceBrokerUpdateRequestLabelQuery) DeleteAllSlice

func (q serviceBrokerUpdateRequestLabelQuery) DeleteAllSlice(o ServiceBrokerUpdateRequestLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceBrokerUpdateRequestLabelQuery) Exists

func (q serviceBrokerUpdateRequestLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceBrokerUpdateRequestLabelQuery) Insert

func (q serviceBrokerUpdateRequestLabelQuery) Insert(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceBrokerUpdateRequestLabelQuery) One

func (q serviceBrokerUpdateRequestLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBrokerUpdateRequestLabel, error)

One returns a single serviceBrokerUpdateRequestLabel record from the query.

func (serviceBrokerUpdateRequestLabelQuery) Reload

func (q serviceBrokerUpdateRequestLabelQuery) Reload(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceBrokerUpdateRequestLabelQuery) ReloadAll

func (q serviceBrokerUpdateRequestLabelQuery) ReloadAll(o *ServiceBrokerUpdateRequestLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceBrokerUpdateRequestLabelQuery) RemoveResource

func (q serviceBrokerUpdateRequestLabelQuery) RemoveResource(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor, related *ServiceBrokerUpdateRequest) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceBrokerUpdateRequestLabelQuery) Resource

func (q serviceBrokerUpdateRequestLabelQuery) Resource(o *ServiceBrokerUpdateRequestLabel, mods ...qm.QueryMod) serviceBrokerUpdateRequestQuery

Resource pointed to by the foreign key.

func (serviceBrokerUpdateRequestLabelQuery) SetResource

func (q serviceBrokerUpdateRequestLabelQuery) SetResource(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceBrokerUpdateRequest) error

SetResource of the serviceBrokerUpdateRequestLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceBrokerUpdateRequestLabels.

func (serviceBrokerUpdateRequestLabelQuery) Update

func (q serviceBrokerUpdateRequestLabelQuery) Update(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceBrokerUpdateRequestLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceBrokerUpdateRequestLabelQuery) UpdateAll

func (q serviceBrokerUpdateRequestLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceBrokerUpdateRequestLabelQuery) UpdateAllSlice

func (q serviceBrokerUpdateRequestLabelQuery) UpdateAllSlice(o ServiceBrokerUpdateRequestLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceBrokerUpdateRequestLabelQuery) Upsert

func (q serviceBrokerUpdateRequestLabelQuery) Upsert(o *ServiceBrokerUpdateRequestLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceBrokerUpdateRequestLabelR

serviceBrokerUpdateRequestLabelR is where relationships are stored.

type serviceBrokerUpdateRequestLabelR struct {
    Resource *ServiceBrokerUpdateRequest `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceBrokerUpdateRequestLabelR) NewStruct

func (*serviceBrokerUpdateRequestLabelR) NewStruct() *serviceBrokerUpdateRequestLabelR

NewStruct creates a new relationship struct

type serviceBrokerUpdateRequestQuery

type serviceBrokerUpdateRequestQuery struct {
    *queries.Query
}

func ServiceBrokerUpdateRequests

func ServiceBrokerUpdateRequests(mods ...qm.QueryMod) serviceBrokerUpdateRequestQuery

ServiceBrokerUpdateRequests retrieves all the records using an executor.

func (serviceBrokerUpdateRequestQuery) AddResourceServiceBrokerUpdateRequestAnnotations

func (q serviceBrokerUpdateRequestQuery) AddResourceServiceBrokerUpdateRequestAnnotations(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBrokerUpdateRequestAnnotation) error

AddResourceServiceBrokerUpdateRequestAnnotations adds the given related objects to the existing relationships of the service_broker_update_request\, optionally inserting them as new records. Appends related to o.R.ResourceServiceBrokerUpdateRequestAnnotations. Sets related.R.Resource appropriately.

func (serviceBrokerUpdateRequestQuery) AddResourceServiceBrokerUpdateRequestLabels

func (q serviceBrokerUpdateRequestQuery) AddResourceServiceBrokerUpdateRequestLabels(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBrokerUpdateRequestLabel) error

AddResourceServiceBrokerUpdateRequestLabels adds the given related objects to the existing relationships of the service_broker_update_request\, optionally inserting them as new records. Appends related to o.R.ResourceServiceBrokerUpdateRequestLabels. Sets related.R.Resource appropriately.

func (serviceBrokerUpdateRequestQuery) All

func (q serviceBrokerUpdateRequestQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceBrokerUpdateRequestSlice, error)

All returns all ServiceBrokerUpdateRequest records from the query.

func (serviceBrokerUpdateRequestQuery) Count

func (q serviceBrokerUpdateRequestQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceBrokerUpdateRequest records in the query.

func (serviceBrokerUpdateRequestQuery) Delete

func (q serviceBrokerUpdateRequestQuery) Delete(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceBrokerUpdateRequest record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceBrokerUpdateRequestQuery) DeleteAll

func (q serviceBrokerUpdateRequestQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceBrokerUpdateRequestQuery) DeleteAllSlice

func (q serviceBrokerUpdateRequestQuery) DeleteAllSlice(o ServiceBrokerUpdateRequestSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceBrokerUpdateRequestQuery) Exists

func (q serviceBrokerUpdateRequestQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceBrokerUpdateRequestQuery) FKServiceBroker

func (q serviceBrokerUpdateRequestQuery) FKServiceBroker(o *ServiceBrokerUpdateRequest, mods ...qm.QueryMod) serviceBrokerQuery

FKServiceBroker pointed to by the foreign key.

func (serviceBrokerUpdateRequestQuery) Insert

func (q serviceBrokerUpdateRequestQuery) Insert(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceBrokerUpdateRequestQuery) One

func (q serviceBrokerUpdateRequestQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceBrokerUpdateRequest, error)

One returns a single serviceBrokerUpdateRequest record from the query.

func (serviceBrokerUpdateRequestQuery) Reload

func (q serviceBrokerUpdateRequestQuery) Reload(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceBrokerUpdateRequestQuery) ReloadAll

func (q serviceBrokerUpdateRequestQuery) ReloadAll(o *ServiceBrokerUpdateRequestSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceBrokerUpdateRequestQuery) RemoveFKServiceBroker

func (q serviceBrokerUpdateRequestQuery) RemoveFKServiceBroker(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, related *ServiceBroker) error

RemoveFKServiceBroker relationship. Sets o.R.FKServiceBroker to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceBrokerUpdateRequestQuery) RemoveResourceServiceBrokerUpdateRequestAnnotations

func (q serviceBrokerUpdateRequestQuery) RemoveResourceServiceBrokerUpdateRequestAnnotations(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceBrokerUpdateRequestAnnotation) error

RemoveResourceServiceBrokerUpdateRequestAnnotations relationships from objects passed in. Removes related items from R.ResourceServiceBrokerUpdateRequestAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceBrokerUpdateRequestQuery) RemoveResourceServiceBrokerUpdateRequestLabels

func (q serviceBrokerUpdateRequestQuery) RemoveResourceServiceBrokerUpdateRequestLabels(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceBrokerUpdateRequestLabel) error

RemoveResourceServiceBrokerUpdateRequestLabels relationships from objects passed in. Removes related items from R.ResourceServiceBrokerUpdateRequestLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceBrokerUpdateRequestQuery) ResourceServiceBrokerUpdateRequestAnnotations

func (q serviceBrokerUpdateRequestQuery) ResourceServiceBrokerUpdateRequestAnnotations(o *ServiceBrokerUpdateRequest, mods ...qm.QueryMod) serviceBrokerUpdateRequestAnnotationQuery

ResourceServiceBrokerUpdateRequestAnnotations retrieves all the service_broker_update_request_annotation's ServiceBrokerUpdateRequestAnnotations with an executor via resource_guid column.

func (serviceBrokerUpdateRequestQuery) ResourceServiceBrokerUpdateRequestLabels

func (q serviceBrokerUpdateRequestQuery) ResourceServiceBrokerUpdateRequestLabels(o *ServiceBrokerUpdateRequest, mods ...qm.QueryMod) serviceBrokerUpdateRequestLabelQuery

ResourceServiceBrokerUpdateRequestLabels retrieves all the service_broker_update_request_label's ServiceBrokerUpdateRequestLabels with an executor via resource_guid column.

func (serviceBrokerUpdateRequestQuery) SetFKServiceBroker

func (q serviceBrokerUpdateRequestQuery) SetFKServiceBroker(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceBroker) error

SetFKServiceBroker of the serviceBrokerUpdateRequest to the related item. Sets o.R.FKServiceBroker to related. Adds o to related.R.FKServiceBrokerServiceBrokerUpdateRequests.

func (serviceBrokerUpdateRequestQuery) SetResourceServiceBrokerUpdateRequestAnnotations

func (q serviceBrokerUpdateRequestQuery) SetResourceServiceBrokerUpdateRequestAnnotations(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBrokerUpdateRequestAnnotation) error

SetResourceServiceBrokerUpdateRequestAnnotations removes all previously related items of the service_broker_update_request replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceBrokerUpdateRequestAnnotations accordingly. Replaces o.R.ResourceServiceBrokerUpdateRequestAnnotations with related. Sets related.R.Resource's ResourceServiceBrokerUpdateRequestAnnotations accordingly.

func (serviceBrokerUpdateRequestQuery) SetResourceServiceBrokerUpdateRequestLabels

func (q serviceBrokerUpdateRequestQuery) SetResourceServiceBrokerUpdateRequestLabels(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBrokerUpdateRequestLabel) error

SetResourceServiceBrokerUpdateRequestLabels removes all previously related items of the service_broker_update_request replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceBrokerUpdateRequestLabels accordingly. Replaces o.R.ResourceServiceBrokerUpdateRequestLabels with related. Sets related.R.Resource's ResourceServiceBrokerUpdateRequestLabels accordingly.

func (serviceBrokerUpdateRequestQuery) Update

func (q serviceBrokerUpdateRequestQuery) Update(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceBrokerUpdateRequest. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceBrokerUpdateRequestQuery) UpdateAll

func (q serviceBrokerUpdateRequestQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceBrokerUpdateRequestQuery) UpdateAllSlice

func (q serviceBrokerUpdateRequestQuery) UpdateAllSlice(o ServiceBrokerUpdateRequestSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceBrokerUpdateRequestQuery) Upsert

func (q serviceBrokerUpdateRequestQuery) Upsert(o *ServiceBrokerUpdateRequest, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceBrokerUpdateRequestR

serviceBrokerUpdateRequestR is where relationships are stored.

type serviceBrokerUpdateRequestR struct {
    FKServiceBroker                               *ServiceBroker                            `boil:"FKServiceBroker" json:"FKServiceBroker" toml:"FKServiceBroker" yaml:"FKServiceBroker"`
    ResourceServiceBrokerUpdateRequestAnnotations ServiceBrokerUpdateRequestAnnotationSlice `boil:"ResourceServiceBrokerUpdateRequestAnnotations" json:"ResourceServiceBrokerUpdateRequestAnnotations" toml:"ResourceServiceBrokerUpdateRequestAnnotations" yaml:"ResourceServiceBrokerUpdateRequestAnnotations"`
    ResourceServiceBrokerUpdateRequestLabels      ServiceBrokerUpdateRequestLabelSlice      `boil:"ResourceServiceBrokerUpdateRequestLabels" json:"ResourceServiceBrokerUpdateRequestLabels" toml:"ResourceServiceBrokerUpdateRequestLabels" yaml:"ResourceServiceBrokerUpdateRequestLabels"`
}

func (*serviceBrokerUpdateRequestR) NewStruct

func (*serviceBrokerUpdateRequestR) NewStruct() *serviceBrokerUpdateRequestR

NewStruct creates a new relationship struct

type serviceDashboardClientL

serviceDashboardClientL is where Load methods for each relationship are stored.

type serviceDashboardClientL struct{}

type serviceDashboardClientQuery

type serviceDashboardClientQuery struct {
    *queries.Query
}

func ServiceDashboardClients

func ServiceDashboardClients(mods ...qm.QueryMod) serviceDashboardClientQuery

ServiceDashboardClients retrieves all the records using an executor.

func (serviceDashboardClientQuery) All

func (q serviceDashboardClientQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceDashboardClientSlice, error)

All returns all ServiceDashboardClient records from the query.

func (serviceDashboardClientQuery) Count

func (q serviceDashboardClientQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceDashboardClient records in the query.

func (serviceDashboardClientQuery) Delete

func (q serviceDashboardClientQuery) Delete(o *ServiceDashboardClient, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceDashboardClient record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceDashboardClientQuery) DeleteAll

func (q serviceDashboardClientQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceDashboardClientQuery) DeleteAllSlice

func (q serviceDashboardClientQuery) DeleteAllSlice(o ServiceDashboardClientSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceDashboardClientQuery) Exists

func (q serviceDashboardClientQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceDashboardClientQuery) Insert

func (q serviceDashboardClientQuery) Insert(o *ServiceDashboardClient, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceDashboardClientQuery) One

func (q serviceDashboardClientQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceDashboardClient, error)

One returns a single serviceDashboardClient record from the query.

func (serviceDashboardClientQuery) Reload

func (q serviceDashboardClientQuery) Reload(o *ServiceDashboardClient, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceDashboardClientQuery) ReloadAll

func (q serviceDashboardClientQuery) ReloadAll(o *ServiceDashboardClientSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceDashboardClientQuery) Update

func (q serviceDashboardClientQuery) Update(o *ServiceDashboardClient, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceDashboardClient. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceDashboardClientQuery) UpdateAll

func (q serviceDashboardClientQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceDashboardClientQuery) UpdateAllSlice

func (q serviceDashboardClientQuery) UpdateAllSlice(o ServiceDashboardClientSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceDashboardClientQuery) Upsert

func (q serviceDashboardClientQuery) Upsert(o *ServiceDashboardClient, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceDashboardClientR

serviceDashboardClientR is where relationships are stored.

type serviceDashboardClientR struct {
}

func (*serviceDashboardClientR) NewStruct

func (*serviceDashboardClientR) NewStruct() *serviceDashboardClientR

NewStruct creates a new relationship struct

type serviceInstanceAnnotationL

serviceInstanceAnnotationL is where Load methods for each relationship are stored.

type serviceInstanceAnnotationL struct{}

func (serviceInstanceAnnotationL) LoadResource

func (serviceInstanceAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstanceAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceInstanceAnnotationQuery

type serviceInstanceAnnotationQuery struct {
    *queries.Query
}

func ServiceInstanceAnnotations

func ServiceInstanceAnnotations(mods ...qm.QueryMod) serviceInstanceAnnotationQuery

ServiceInstanceAnnotations retrieves all the records using an executor.

func (serviceInstanceAnnotationQuery) All

func (q serviceInstanceAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceInstanceAnnotationSlice, error)

All returns all ServiceInstanceAnnotation records from the query.

func (serviceInstanceAnnotationQuery) Count

func (q serviceInstanceAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceInstanceAnnotation records in the query.

func (serviceInstanceAnnotationQuery) Delete

func (q serviceInstanceAnnotationQuery) Delete(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceInstanceAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceInstanceAnnotationQuery) DeleteAll

func (q serviceInstanceAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceInstanceAnnotationQuery) DeleteAllSlice

func (q serviceInstanceAnnotationQuery) DeleteAllSlice(o ServiceInstanceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceInstanceAnnotationQuery) Exists

func (q serviceInstanceAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceInstanceAnnotationQuery) Insert

func (q serviceInstanceAnnotationQuery) Insert(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceInstanceAnnotationQuery) One

func (q serviceInstanceAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceInstanceAnnotation, error)

One returns a single serviceInstanceAnnotation record from the query.

func (serviceInstanceAnnotationQuery) Reload

func (q serviceInstanceAnnotationQuery) Reload(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceInstanceAnnotationQuery) ReloadAll

func (q serviceInstanceAnnotationQuery) ReloadAll(o *ServiceInstanceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceInstanceAnnotationQuery) RemoveResource

func (q serviceInstanceAnnotationQuery) RemoveResource(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor, related *ServiceInstance) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceInstanceAnnotationQuery) Resource

func (q serviceInstanceAnnotationQuery) Resource(o *ServiceInstanceAnnotation, mods ...qm.QueryMod) serviceInstanceQuery

Resource pointed to by the foreign key.

func (serviceInstanceAnnotationQuery) SetResource

func (q serviceInstanceAnnotationQuery) SetResource(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceInstance) error

SetResource of the serviceInstanceAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceInstanceAnnotations.

func (serviceInstanceAnnotationQuery) Update

func (q serviceInstanceAnnotationQuery) Update(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceInstanceAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceInstanceAnnotationQuery) UpdateAll

func (q serviceInstanceAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceInstanceAnnotationQuery) UpdateAllSlice

func (q serviceInstanceAnnotationQuery) UpdateAllSlice(o ServiceInstanceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceInstanceAnnotationQuery) Upsert

func (q serviceInstanceAnnotationQuery) Upsert(o *ServiceInstanceAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceInstanceAnnotationR

serviceInstanceAnnotationR is where relationships are stored.

type serviceInstanceAnnotationR struct {
    Resource *ServiceInstance `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceInstanceAnnotationR) NewStruct

func (*serviceInstanceAnnotationR) NewStruct() *serviceInstanceAnnotationR

NewStruct creates a new relationship struct

type serviceInstanceL

serviceInstanceL is where Load methods for each relationship are stored.

type serviceInstanceL struct{}

func (serviceInstanceL) LoadResourceServiceInstanceAnnotations

func (serviceInstanceL) LoadResourceServiceInstanceAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstance interface{}, mods queries.Applicator) error

LoadResourceServiceInstanceAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceInstanceL) LoadResourceServiceInstanceLabels

func (serviceInstanceL) LoadResourceServiceInstanceLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstance interface{}, mods queries.Applicator) error

LoadResourceServiceInstanceLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceInstanceL) LoadRouteBindings

func (serviceInstanceL) LoadRouteBindings(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstance interface{}, mods queries.Applicator) error

LoadRouteBindings allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceInstanceL) LoadServiceBindings

func (serviceInstanceL) LoadServiceBindings(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstance interface{}, mods queries.Applicator) error

LoadServiceBindings allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceInstanceL) LoadServiceInstanceOperations

func (serviceInstanceL) LoadServiceInstanceOperations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstance interface{}, mods queries.Applicator) error

LoadServiceInstanceOperations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceInstanceL) LoadServiceKeys

func (serviceInstanceL) LoadServiceKeys(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstance interface{}, mods queries.Applicator) error

LoadServiceKeys allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceInstanceL) LoadServicePlan

func (serviceInstanceL) LoadServicePlan(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstance interface{}, mods queries.Applicator) error

LoadServicePlan allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (serviceInstanceL) LoadSpace

func (serviceInstanceL) LoadSpace(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstance interface{}, mods queries.Applicator) error

LoadSpace allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (serviceInstanceL) LoadSpaces

func (serviceInstanceL) LoadSpaces(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstance interface{}, mods queries.Applicator) error

LoadSpaces allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type serviceInstanceLabelL

serviceInstanceLabelL is where Load methods for each relationship are stored.

type serviceInstanceLabelL struct{}

func (serviceInstanceLabelL) LoadResource

func (serviceInstanceLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstanceLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceInstanceLabelQuery

type serviceInstanceLabelQuery struct {
    *queries.Query
}

func ServiceInstanceLabels

func ServiceInstanceLabels(mods ...qm.QueryMod) serviceInstanceLabelQuery

ServiceInstanceLabels retrieves all the records using an executor.

func (serviceInstanceLabelQuery) All

func (q serviceInstanceLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceInstanceLabelSlice, error)

All returns all ServiceInstanceLabel records from the query.

func (serviceInstanceLabelQuery) Count

func (q serviceInstanceLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceInstanceLabel records in the query.

func (serviceInstanceLabelQuery) Delete

func (q serviceInstanceLabelQuery) Delete(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceInstanceLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceInstanceLabelQuery) DeleteAll

func (q serviceInstanceLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceInstanceLabelQuery) DeleteAllSlice

func (q serviceInstanceLabelQuery) DeleteAllSlice(o ServiceInstanceLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceInstanceLabelQuery) Exists

func (q serviceInstanceLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceInstanceLabelQuery) Insert

func (q serviceInstanceLabelQuery) Insert(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceInstanceLabelQuery) One

func (q serviceInstanceLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceInstanceLabel, error)

One returns a single serviceInstanceLabel record from the query.

func (serviceInstanceLabelQuery) Reload

func (q serviceInstanceLabelQuery) Reload(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceInstanceLabelQuery) ReloadAll

func (q serviceInstanceLabelQuery) ReloadAll(o *ServiceInstanceLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceInstanceLabelQuery) RemoveResource

func (q serviceInstanceLabelQuery) RemoveResource(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor, related *ServiceInstance) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceInstanceLabelQuery) Resource

func (q serviceInstanceLabelQuery) Resource(o *ServiceInstanceLabel, mods ...qm.QueryMod) serviceInstanceQuery

Resource pointed to by the foreign key.

func (serviceInstanceLabelQuery) SetResource

func (q serviceInstanceLabelQuery) SetResource(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceInstance) error

SetResource of the serviceInstanceLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceInstanceLabels.

func (serviceInstanceLabelQuery) Update

func (q serviceInstanceLabelQuery) Update(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceInstanceLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceInstanceLabelQuery) UpdateAll

func (q serviceInstanceLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceInstanceLabelQuery) UpdateAllSlice

func (q serviceInstanceLabelQuery) UpdateAllSlice(o ServiceInstanceLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceInstanceLabelQuery) Upsert

func (q serviceInstanceLabelQuery) Upsert(o *ServiceInstanceLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceInstanceLabelR

serviceInstanceLabelR is where relationships are stored.

type serviceInstanceLabelR struct {
    Resource *ServiceInstance `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceInstanceLabelR) NewStruct

func (*serviceInstanceLabelR) NewStruct() *serviceInstanceLabelR

NewStruct creates a new relationship struct

type serviceInstanceOperationL

serviceInstanceOperationL is where Load methods for each relationship are stored.

type serviceInstanceOperationL struct{}

func (serviceInstanceOperationL) LoadServiceInstance

func (serviceInstanceOperationL) LoadServiceInstance(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceInstanceOperation interface{}, mods queries.Applicator) error

LoadServiceInstance allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceInstanceOperationQuery

type serviceInstanceOperationQuery struct {
    *queries.Query
}

func ServiceInstanceOperations

func ServiceInstanceOperations(mods ...qm.QueryMod) serviceInstanceOperationQuery

ServiceInstanceOperations retrieves all the records using an executor.

func (serviceInstanceOperationQuery) All

func (q serviceInstanceOperationQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceInstanceOperationSlice, error)

All returns all ServiceInstanceOperation records from the query.

func (serviceInstanceOperationQuery) Count

func (q serviceInstanceOperationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceInstanceOperation records in the query.

func (serviceInstanceOperationQuery) Delete

func (q serviceInstanceOperationQuery) Delete(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceInstanceOperation record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceInstanceOperationQuery) DeleteAll

func (q serviceInstanceOperationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceInstanceOperationQuery) DeleteAllSlice

func (q serviceInstanceOperationQuery) DeleteAllSlice(o ServiceInstanceOperationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceInstanceOperationQuery) Exists

func (q serviceInstanceOperationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceInstanceOperationQuery) Insert

func (q serviceInstanceOperationQuery) Insert(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceInstanceOperationQuery) One

func (q serviceInstanceOperationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceInstanceOperation, error)

One returns a single serviceInstanceOperation record from the query.

func (serviceInstanceOperationQuery) Reload

func (q serviceInstanceOperationQuery) Reload(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceInstanceOperationQuery) ReloadAll

func (q serviceInstanceOperationQuery) ReloadAll(o *ServiceInstanceOperationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceInstanceOperationQuery) RemoveServiceInstance

func (q serviceInstanceOperationQuery) RemoveServiceInstance(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor, related *ServiceInstance) error

RemoveServiceInstance relationship. Sets o.R.ServiceInstance to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceInstanceOperationQuery) ServiceInstance

func (q serviceInstanceOperationQuery) ServiceInstance(o *ServiceInstanceOperation, mods ...qm.QueryMod) serviceInstanceQuery

ServiceInstance pointed to by the foreign key.

func (serviceInstanceOperationQuery) SetServiceInstance

func (q serviceInstanceOperationQuery) SetServiceInstance(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceInstance) error

SetServiceInstance of the serviceInstanceOperation to the related item. Sets o.R.ServiceInstance to related. Adds o to related.R.ServiceInstanceOperations.

func (serviceInstanceOperationQuery) Update

func (q serviceInstanceOperationQuery) Update(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceInstanceOperation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceInstanceOperationQuery) UpdateAll

func (q serviceInstanceOperationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceInstanceOperationQuery) UpdateAllSlice

func (q serviceInstanceOperationQuery) UpdateAllSlice(o ServiceInstanceOperationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceInstanceOperationQuery) Upsert

func (q serviceInstanceOperationQuery) Upsert(o *ServiceInstanceOperation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceInstanceOperationR

serviceInstanceOperationR is where relationships are stored.

type serviceInstanceOperationR struct {
    ServiceInstance *ServiceInstance `boil:"ServiceInstance" json:"ServiceInstance" toml:"ServiceInstance" yaml:"ServiceInstance"`
}

func (*serviceInstanceOperationR) NewStruct

func (*serviceInstanceOperationR) NewStruct() *serviceInstanceOperationR

NewStruct creates a new relationship struct

type serviceInstanceQuery

type serviceInstanceQuery struct {
    *queries.Query
}

func ServiceInstances

func ServiceInstances(mods ...qm.QueryMod) serviceInstanceQuery

ServiceInstances retrieves all the records using an executor.

func (serviceInstanceQuery) AddResourceServiceInstanceAnnotations

func (q serviceInstanceQuery) AddResourceServiceInstanceAnnotations(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceInstanceAnnotation) error

AddResourceServiceInstanceAnnotations adds the given related objects to the existing relationships of the service_instance\, optionally inserting them as new records. Appends related to o.R.ResourceServiceInstanceAnnotations. Sets related.R.Resource appropriately.

func (serviceInstanceQuery) AddResourceServiceInstanceLabels

func (q serviceInstanceQuery) AddResourceServiceInstanceLabels(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceInstanceLabel) error

AddResourceServiceInstanceLabels adds the given related objects to the existing relationships of the service_instance\, optionally inserting them as new records. Appends related to o.R.ResourceServiceInstanceLabels. Sets related.R.Resource appropriately.

func (serviceInstanceQuery) AddRouteBindings

func (q serviceInstanceQuery) AddRouteBindings(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteBinding) error

AddRouteBindings adds the given related objects to the existing relationships of the service_instance\, optionally inserting them as new records. Appends related to o.R.RouteBindings. Sets related.R.ServiceInstance appropriately.

func (serviceInstanceQuery) AddServiceBindings

func (q serviceInstanceQuery) AddServiceBindings(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBinding) error

AddServiceBindings adds the given related objects to the existing relationships of the service_instance\, optionally inserting them as new records. Appends related to o.R.ServiceBindings. Sets related.R.ServiceInstance appropriately.

func (serviceInstanceQuery) AddServiceInstanceOperations

func (q serviceInstanceQuery) AddServiceInstanceOperations(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceInstanceOperation) error

AddServiceInstanceOperations adds the given related objects to the existing relationships of the service_instance\, optionally inserting them as new records. Appends related to o.R.ServiceInstanceOperations. Sets related.R.ServiceInstance appropriately.

func (serviceInstanceQuery) AddServiceKeys

func (q serviceInstanceQuery) AddServiceKeys(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceKey) error

AddServiceKeys adds the given related objects to the existing relationships of the service_instance\, optionally inserting them as new records. Appends related to o.R.ServiceKeys. Sets related.R.ServiceInstance appropriately.

func (serviceInstanceQuery) AddSpaces

func (q serviceInstanceQuery) AddSpaces(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Space) error

AddSpaces adds the given related objects to the existing relationships of the service_instance\, optionally inserting them as new records. Appends related to o.R.Spaces. Sets related.R.SharedServiceInstances appropriately.

func (serviceInstanceQuery) All

func (q serviceInstanceQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceInstanceSlice, error)

All returns all ServiceInstance records from the query.

func (serviceInstanceQuery) Count

func (q serviceInstanceQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceInstance records in the query.

func (serviceInstanceQuery) Delete

func (q serviceInstanceQuery) Delete(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceInstance record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceInstanceQuery) DeleteAll

func (q serviceInstanceQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceInstanceQuery) DeleteAllSlice

func (q serviceInstanceQuery) DeleteAllSlice(o ServiceInstanceSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceInstanceQuery) Exists

func (q serviceInstanceQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceInstanceQuery) Insert

func (q serviceInstanceQuery) Insert(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceInstanceQuery) One

func (q serviceInstanceQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceInstance, error)

One returns a single serviceInstance record from the query.

func (serviceInstanceQuery) Reload

func (q serviceInstanceQuery) Reload(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceInstanceQuery) ReloadAll

func (q serviceInstanceQuery) ReloadAll(o *ServiceInstanceSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceInstanceQuery) RemoveResourceServiceInstanceAnnotations

func (q serviceInstanceQuery) RemoveResourceServiceInstanceAnnotations(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceInstanceAnnotation) error

RemoveResourceServiceInstanceAnnotations relationships from objects passed in. Removes related items from R.ResourceServiceInstanceAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceInstanceQuery) RemoveResourceServiceInstanceLabels

func (q serviceInstanceQuery) RemoveResourceServiceInstanceLabels(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceInstanceLabel) error

RemoveResourceServiceInstanceLabels relationships from objects passed in. Removes related items from R.ResourceServiceInstanceLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceInstanceQuery) RemoveRouteBindings

func (q serviceInstanceQuery) RemoveRouteBindings(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, related ...*RouteBinding) error

RemoveRouteBindings relationships from objects passed in. Removes related items from R.RouteBindings (uses pointer comparison\, removal does not keep order) Sets related.R.ServiceInstance.

func (serviceInstanceQuery) RemoveServiceInstanceOperations

func (q serviceInstanceQuery) RemoveServiceInstanceOperations(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceInstanceOperation) error

RemoveServiceInstanceOperations relationships from objects passed in. Removes related items from R.ServiceInstanceOperations (uses pointer comparison\, removal does not keep order) Sets related.R.ServiceInstance.

func (serviceInstanceQuery) RemoveServicePlan

func (q serviceInstanceQuery) RemoveServicePlan(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, related *ServicePlan) error

RemoveServicePlan relationship. Sets o.R.ServicePlan to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceInstanceQuery) RemoveSpaces

func (q serviceInstanceQuery) RemoveSpaces(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, related ...*Space) error

RemoveSpaces relationships from objects passed in. Removes related items from R.Spaces (uses pointer comparison\, removal does not keep order) Sets related.R.SharedServiceInstances.

func (serviceInstanceQuery) ResourceServiceInstanceAnnotations

func (q serviceInstanceQuery) ResourceServiceInstanceAnnotations(o *ServiceInstance, mods ...qm.QueryMod) serviceInstanceAnnotationQuery

ResourceServiceInstanceAnnotations retrieves all the service_instance_annotation's ServiceInstanceAnnotations with an executor via resource_guid column.

func (serviceInstanceQuery) ResourceServiceInstanceLabels

func (q serviceInstanceQuery) ResourceServiceInstanceLabels(o *ServiceInstance, mods ...qm.QueryMod) serviceInstanceLabelQuery

ResourceServiceInstanceLabels retrieves all the service_instance_label's ServiceInstanceLabels with an executor via resource_guid column.

func (serviceInstanceQuery) RouteBindings

func (q serviceInstanceQuery) RouteBindings(o *ServiceInstance, mods ...qm.QueryMod) routeBindingQuery

RouteBindings retrieves all the route_binding's RouteBindings with an executor.

func (serviceInstanceQuery) ServiceBindings

func (q serviceInstanceQuery) ServiceBindings(o *ServiceInstance, mods ...qm.QueryMod) serviceBindingQuery

ServiceBindings retrieves all the service_binding's ServiceBindings with an executor.

func (serviceInstanceQuery) ServiceInstanceOperations

func (q serviceInstanceQuery) ServiceInstanceOperations(o *ServiceInstance, mods ...qm.QueryMod) serviceInstanceOperationQuery

ServiceInstanceOperations retrieves all the service_instance_operation's ServiceInstanceOperations with an executor.

func (serviceInstanceQuery) ServiceKeys

func (q serviceInstanceQuery) ServiceKeys(o *ServiceInstance, mods ...qm.QueryMod) serviceKeyQuery

ServiceKeys retrieves all the service_key's ServiceKeys with an executor.

func (serviceInstanceQuery) ServicePlan

func (q serviceInstanceQuery) ServicePlan(o *ServiceInstance, mods ...qm.QueryMod) servicePlanQuery

ServicePlan pointed to by the foreign key.

func (serviceInstanceQuery) SetResourceServiceInstanceAnnotations

func (q serviceInstanceQuery) SetResourceServiceInstanceAnnotations(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceInstanceAnnotation) error

SetResourceServiceInstanceAnnotations removes all previously related items of the service_instance replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceInstanceAnnotations accordingly. Replaces o.R.ResourceServiceInstanceAnnotations with related. Sets related.R.Resource's ResourceServiceInstanceAnnotations accordingly.

func (serviceInstanceQuery) SetResourceServiceInstanceLabels

func (q serviceInstanceQuery) SetResourceServiceInstanceLabels(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceInstanceLabel) error

SetResourceServiceInstanceLabels removes all previously related items of the service_instance replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceInstanceLabels accordingly. Replaces o.R.ResourceServiceInstanceLabels with related. Sets related.R.Resource's ResourceServiceInstanceLabels accordingly.

func (serviceInstanceQuery) SetRouteBindings

func (q serviceInstanceQuery) SetRouteBindings(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*RouteBinding) error

SetRouteBindings removes all previously related items of the service_instance replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.ServiceInstance's RouteBindings accordingly. Replaces o.R.RouteBindings with related. Sets related.R.ServiceInstance's RouteBindings accordingly.

func (serviceInstanceQuery) SetServiceInstanceOperations

func (q serviceInstanceQuery) SetServiceInstanceOperations(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceInstanceOperation) error

SetServiceInstanceOperations removes all previously related items of the service_instance replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.ServiceInstance's ServiceInstanceOperations accordingly. Replaces o.R.ServiceInstanceOperations with related. Sets related.R.ServiceInstance's ServiceInstanceOperations accordingly.

func (serviceInstanceQuery) SetServicePlan

func (q serviceInstanceQuery) SetServicePlan(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServicePlan) error

SetServicePlan of the serviceInstance to the related item. Sets o.R.ServicePlan to related. Adds o to related.R.ServiceInstances.

func (serviceInstanceQuery) SetSpace

func (q serviceInstanceQuery) SetSpace(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetSpace of the serviceInstance to the related item. Sets o.R.Space to related. Adds o to related.R.ServiceInstances.

func (serviceInstanceQuery) SetSpaces

func (q serviceInstanceQuery) SetSpaces(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Space) error

SetSpaces removes all previously related items of the service_instance replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.SharedServiceInstances's Spaces accordingly. Replaces o.R.Spaces with related. Sets related.R.SharedServiceInstances's Spaces accordingly.

func (serviceInstanceQuery) Space

func (q serviceInstanceQuery) Space(o *ServiceInstance, mods ...qm.QueryMod) spaceQuery

Space pointed to by the foreign key.

func (serviceInstanceQuery) Spaces

func (q serviceInstanceQuery) Spaces(o *ServiceInstance, mods ...qm.QueryMod) spaceQuery

Spaces retrieves all the space's Spaces with an executor.

func (serviceInstanceQuery) Update

func (q serviceInstanceQuery) Update(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceInstance. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceInstanceQuery) UpdateAll

func (q serviceInstanceQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceInstanceQuery) UpdateAllSlice

func (q serviceInstanceQuery) UpdateAllSlice(o ServiceInstanceSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceInstanceQuery) Upsert

func (q serviceInstanceQuery) Upsert(o *ServiceInstance, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceInstanceR

serviceInstanceR is where relationships are stored.

type serviceInstanceR struct {
    Space                              *Space                         `boil:"Space" json:"Space" toml:"Space" yaml:"Space"`
    ServicePlan                        *ServicePlan                   `boil:"ServicePlan" json:"ServicePlan" toml:"ServicePlan" yaml:"ServicePlan"`
    RouteBindings                      RouteBindingSlice              `boil:"RouteBindings" json:"RouteBindings" toml:"RouteBindings" yaml:"RouteBindings"`
    ServiceBindings                    ServiceBindingSlice            `boil:"ServiceBindings" json:"ServiceBindings" toml:"ServiceBindings" yaml:"ServiceBindings"`
    ResourceServiceInstanceAnnotations ServiceInstanceAnnotationSlice `boil:"ResourceServiceInstanceAnnotations" json:"ResourceServiceInstanceAnnotations" toml:"ResourceServiceInstanceAnnotations" yaml:"ResourceServiceInstanceAnnotations"`
    ResourceServiceInstanceLabels      ServiceInstanceLabelSlice      `boil:"ResourceServiceInstanceLabels" json:"ResourceServiceInstanceLabels" toml:"ResourceServiceInstanceLabels" yaml:"ResourceServiceInstanceLabels"`
    ServiceInstanceOperations          ServiceInstanceOperationSlice  `boil:"ServiceInstanceOperations" json:"ServiceInstanceOperations" toml:"ServiceInstanceOperations" yaml:"ServiceInstanceOperations"`
    Spaces                             SpaceSlice                     `boil:"Spaces" json:"Spaces" toml:"Spaces" yaml:"Spaces"`
    ServiceKeys                        ServiceKeySlice                `boil:"ServiceKeys" json:"ServiceKeys" toml:"ServiceKeys" yaml:"ServiceKeys"`
}

func (*serviceInstanceR) NewStruct

func (*serviceInstanceR) NewStruct() *serviceInstanceR

NewStruct creates a new relationship struct

type serviceKeyAnnotationL

serviceKeyAnnotationL is where Load methods for each relationship are stored.

type serviceKeyAnnotationL struct{}

func (serviceKeyAnnotationL) LoadResource

func (serviceKeyAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceKeyAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceKeyAnnotationQuery

type serviceKeyAnnotationQuery struct {
    *queries.Query
}

func ServiceKeyAnnotations

func ServiceKeyAnnotations(mods ...qm.QueryMod) serviceKeyAnnotationQuery

ServiceKeyAnnotations retrieves all the records using an executor.

func (serviceKeyAnnotationQuery) All

func (q serviceKeyAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceKeyAnnotationSlice, error)

All returns all ServiceKeyAnnotation records from the query.

func (serviceKeyAnnotationQuery) Count

func (q serviceKeyAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceKeyAnnotation records in the query.

func (serviceKeyAnnotationQuery) Delete

func (q serviceKeyAnnotationQuery) Delete(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceKeyAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceKeyAnnotationQuery) DeleteAll

func (q serviceKeyAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceKeyAnnotationQuery) DeleteAllSlice

func (q serviceKeyAnnotationQuery) DeleteAllSlice(o ServiceKeyAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceKeyAnnotationQuery) Exists

func (q serviceKeyAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceKeyAnnotationQuery) Insert

func (q serviceKeyAnnotationQuery) Insert(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceKeyAnnotationQuery) One

func (q serviceKeyAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceKeyAnnotation, error)

One returns a single serviceKeyAnnotation record from the query.

func (serviceKeyAnnotationQuery) Reload

func (q serviceKeyAnnotationQuery) Reload(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceKeyAnnotationQuery) ReloadAll

func (q serviceKeyAnnotationQuery) ReloadAll(o *ServiceKeyAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceKeyAnnotationQuery) RemoveResource

func (q serviceKeyAnnotationQuery) RemoveResource(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor, related *ServiceKey) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceKeyAnnotationQuery) Resource

func (q serviceKeyAnnotationQuery) Resource(o *ServiceKeyAnnotation, mods ...qm.QueryMod) serviceKeyQuery

Resource pointed to by the foreign key.

func (serviceKeyAnnotationQuery) SetResource

func (q serviceKeyAnnotationQuery) SetResource(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceKey) error

SetResource of the serviceKeyAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceKeyAnnotations.

func (serviceKeyAnnotationQuery) Update

func (q serviceKeyAnnotationQuery) Update(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceKeyAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceKeyAnnotationQuery) UpdateAll

func (q serviceKeyAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceKeyAnnotationQuery) UpdateAllSlice

func (q serviceKeyAnnotationQuery) UpdateAllSlice(o ServiceKeyAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceKeyAnnotationQuery) Upsert

func (q serviceKeyAnnotationQuery) Upsert(o *ServiceKeyAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceKeyAnnotationR

serviceKeyAnnotationR is where relationships are stored.

type serviceKeyAnnotationR struct {
    Resource *ServiceKey `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceKeyAnnotationR) NewStruct

func (*serviceKeyAnnotationR) NewStruct() *serviceKeyAnnotationR

NewStruct creates a new relationship struct

type serviceKeyL

serviceKeyL is where Load methods for each relationship are stored.

type serviceKeyL struct{}

func (serviceKeyL) LoadResourceServiceKeyAnnotations

func (serviceKeyL) LoadResourceServiceKeyAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceKey interface{}, mods queries.Applicator) error

LoadResourceServiceKeyAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceKeyL) LoadResourceServiceKeyLabels

func (serviceKeyL) LoadResourceServiceKeyLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceKey interface{}, mods queries.Applicator) error

LoadResourceServiceKeyLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceKeyL) LoadServiceInstance

func (serviceKeyL) LoadServiceInstance(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceKey interface{}, mods queries.Applicator) error

LoadServiceInstance allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (serviceKeyL) LoadServiceKeyOperation

func (serviceKeyL) LoadServiceKeyOperation(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceKey interface{}, mods queries.Applicator) error

LoadServiceKeyOperation allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-1 relationship.

type serviceKeyLabelL

serviceKeyLabelL is where Load methods for each relationship are stored.

type serviceKeyLabelL struct{}

func (serviceKeyLabelL) LoadResource

func (serviceKeyLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceKeyLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceKeyLabelQuery

type serviceKeyLabelQuery struct {
    *queries.Query
}

func ServiceKeyLabels

func ServiceKeyLabels(mods ...qm.QueryMod) serviceKeyLabelQuery

ServiceKeyLabels retrieves all the records using an executor.

func (serviceKeyLabelQuery) All

func (q serviceKeyLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceKeyLabelSlice, error)

All returns all ServiceKeyLabel records from the query.

func (serviceKeyLabelQuery) Count

func (q serviceKeyLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceKeyLabel records in the query.

func (serviceKeyLabelQuery) Delete

func (q serviceKeyLabelQuery) Delete(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceKeyLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceKeyLabelQuery) DeleteAll

func (q serviceKeyLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceKeyLabelQuery) DeleteAllSlice

func (q serviceKeyLabelQuery) DeleteAllSlice(o ServiceKeyLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceKeyLabelQuery) Exists

func (q serviceKeyLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceKeyLabelQuery) Insert

func (q serviceKeyLabelQuery) Insert(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceKeyLabelQuery) One

func (q serviceKeyLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceKeyLabel, error)

One returns a single serviceKeyLabel record from the query.

func (serviceKeyLabelQuery) Reload

func (q serviceKeyLabelQuery) Reload(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceKeyLabelQuery) ReloadAll

func (q serviceKeyLabelQuery) ReloadAll(o *ServiceKeyLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceKeyLabelQuery) RemoveResource

func (q serviceKeyLabelQuery) RemoveResource(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor, related *ServiceKey) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceKeyLabelQuery) Resource

func (q serviceKeyLabelQuery) Resource(o *ServiceKeyLabel, mods ...qm.QueryMod) serviceKeyQuery

Resource pointed to by the foreign key.

func (serviceKeyLabelQuery) SetResource

func (q serviceKeyLabelQuery) SetResource(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceKey) error

SetResource of the serviceKeyLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceKeyLabels.

func (serviceKeyLabelQuery) Update

func (q serviceKeyLabelQuery) Update(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceKeyLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceKeyLabelQuery) UpdateAll

func (q serviceKeyLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceKeyLabelQuery) UpdateAllSlice

func (q serviceKeyLabelQuery) UpdateAllSlice(o ServiceKeyLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceKeyLabelQuery) Upsert

func (q serviceKeyLabelQuery) Upsert(o *ServiceKeyLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceKeyLabelR

serviceKeyLabelR is where relationships are stored.

type serviceKeyLabelR struct {
    Resource *ServiceKey `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceKeyLabelR) NewStruct

func (*serviceKeyLabelR) NewStruct() *serviceKeyLabelR

NewStruct creates a new relationship struct

type serviceKeyOperationL

serviceKeyOperationL is where Load methods for each relationship are stored.

type serviceKeyOperationL struct{}

func (serviceKeyOperationL) LoadServiceKey

func (serviceKeyOperationL) LoadServiceKey(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceKeyOperation interface{}, mods queries.Applicator) error

LoadServiceKey allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceKeyOperationQuery

type serviceKeyOperationQuery struct {
    *queries.Query
}

func ServiceKeyOperations

func ServiceKeyOperations(mods ...qm.QueryMod) serviceKeyOperationQuery

ServiceKeyOperations retrieves all the records using an executor.

func (serviceKeyOperationQuery) All

func (q serviceKeyOperationQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceKeyOperationSlice, error)

All returns all ServiceKeyOperation records from the query.

func (serviceKeyOperationQuery) Count

func (q serviceKeyOperationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceKeyOperation records in the query.

func (serviceKeyOperationQuery) Delete

func (q serviceKeyOperationQuery) Delete(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceKeyOperation record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceKeyOperationQuery) DeleteAll

func (q serviceKeyOperationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceKeyOperationQuery) DeleteAllSlice

func (q serviceKeyOperationQuery) DeleteAllSlice(o ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceKeyOperationQuery) Exists

func (q serviceKeyOperationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceKeyOperationQuery) Insert

func (q serviceKeyOperationQuery) Insert(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceKeyOperationQuery) One

func (q serviceKeyOperationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceKeyOperation, error)

One returns a single serviceKeyOperation record from the query.

func (serviceKeyOperationQuery) Reload

func (q serviceKeyOperationQuery) Reload(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceKeyOperationQuery) ReloadAll

func (q serviceKeyOperationQuery) ReloadAll(o *ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceKeyOperationQuery) RemoveServiceKey

func (q serviceKeyOperationQuery) RemoveServiceKey(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, related *ServiceKey) error

RemoveServiceKey relationship. Sets o.R.ServiceKey to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceKeyOperationQuery) ServiceKey

func (q serviceKeyOperationQuery) ServiceKey(o *ServiceKeyOperation, mods ...qm.QueryMod) serviceKeyQuery

ServiceKey pointed to by the foreign key.

func (serviceKeyOperationQuery) SetServiceKey

func (q serviceKeyOperationQuery) SetServiceKey(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceKey) error

SetServiceKey of the serviceKeyOperation to the related item. Sets o.R.ServiceKey to related. Adds o to related.R.ServiceKeyOperation.

func (serviceKeyOperationQuery) Update

func (q serviceKeyOperationQuery) Update(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceKeyOperation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceKeyOperationQuery) UpdateAll

func (q serviceKeyOperationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceKeyOperationQuery) UpdateAllSlice

func (q serviceKeyOperationQuery) UpdateAllSlice(o ServiceKeyOperationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceKeyOperationQuery) Upsert

func (q serviceKeyOperationQuery) Upsert(o *ServiceKeyOperation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceKeyOperationR

serviceKeyOperationR is where relationships are stored.

type serviceKeyOperationR struct {
    ServiceKey *ServiceKey `boil:"ServiceKey" json:"ServiceKey" toml:"ServiceKey" yaml:"ServiceKey"`
}

func (*serviceKeyOperationR) NewStruct

func (*serviceKeyOperationR) NewStruct() *serviceKeyOperationR

NewStruct creates a new relationship struct

type serviceKeyQuery

type serviceKeyQuery struct {
    *queries.Query
}

func ServiceKeys

func ServiceKeys(mods ...qm.QueryMod) serviceKeyQuery

ServiceKeys retrieves all the records using an executor.

func (serviceKeyQuery) AddResourceServiceKeyAnnotations

func (q serviceKeyQuery) AddResourceServiceKeyAnnotations(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceKeyAnnotation) error

AddResourceServiceKeyAnnotations adds the given related objects to the existing relationships of the service_key\, optionally inserting them as new records. Appends related to o.R.ResourceServiceKeyAnnotations. Sets related.R.Resource appropriately.

func (serviceKeyQuery) AddResourceServiceKeyLabels

func (q serviceKeyQuery) AddResourceServiceKeyLabels(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceKeyLabel) error

AddResourceServiceKeyLabels adds the given related objects to the existing relationships of the service_key\, optionally inserting them as new records. Appends related to o.R.ResourceServiceKeyLabels. Sets related.R.Resource appropriately.

func (serviceKeyQuery) All

func (q serviceKeyQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceKeySlice, error)

All returns all ServiceKey records from the query.

func (serviceKeyQuery) Count

func (q serviceKeyQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceKey records in the query.

func (serviceKeyQuery) Delete

func (q serviceKeyQuery) Delete(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceKey record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceKeyQuery) DeleteAll

func (q serviceKeyQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceKeyQuery) DeleteAllSlice

func (q serviceKeyQuery) DeleteAllSlice(o ServiceKeySlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceKeyQuery) Exists

func (q serviceKeyQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceKeyQuery) Insert

func (q serviceKeyQuery) Insert(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceKeyQuery) One

func (q serviceKeyQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceKey, error)

One returns a single serviceKey record from the query.

func (serviceKeyQuery) Reload

func (q serviceKeyQuery) Reload(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceKeyQuery) ReloadAll

func (q serviceKeyQuery) ReloadAll(o *ServiceKeySlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceKeyQuery) RemoveResourceServiceKeyAnnotations

func (q serviceKeyQuery) RemoveResourceServiceKeyAnnotations(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceKeyAnnotation) error

RemoveResourceServiceKeyAnnotations relationships from objects passed in. Removes related items from R.ResourceServiceKeyAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceKeyQuery) RemoveResourceServiceKeyLabels

func (q serviceKeyQuery) RemoveResourceServiceKeyLabels(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceKeyLabel) error

RemoveResourceServiceKeyLabels relationships from objects passed in. Removes related items from R.ResourceServiceKeyLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceKeyQuery) RemoveServiceKeyOperation

func (q serviceKeyQuery) RemoveServiceKeyOperation(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, related *ServiceKeyOperation) error

RemoveServiceKeyOperation relationship. Sets o.R.ServiceKeyOperation to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceKeyQuery) ResourceServiceKeyAnnotations

func (q serviceKeyQuery) ResourceServiceKeyAnnotations(o *ServiceKey, mods ...qm.QueryMod) serviceKeyAnnotationQuery

ResourceServiceKeyAnnotations retrieves all the service_key_annotation's ServiceKeyAnnotations with an executor via resource_guid column.

func (serviceKeyQuery) ResourceServiceKeyLabels

func (q serviceKeyQuery) ResourceServiceKeyLabels(o *ServiceKey, mods ...qm.QueryMod) serviceKeyLabelQuery

ResourceServiceKeyLabels retrieves all the service_key_label's ServiceKeyLabels with an executor via resource_guid column.

func (serviceKeyQuery) ServiceInstance

func (q serviceKeyQuery) ServiceInstance(o *ServiceKey, mods ...qm.QueryMod) serviceInstanceQuery

ServiceInstance pointed to by the foreign key.

func (serviceKeyQuery) ServiceKeyOperation

func (q serviceKeyQuery) ServiceKeyOperation(o *ServiceKey, mods ...qm.QueryMod) serviceKeyOperationQuery

ServiceKeyOperation pointed to by the foreign key.

func (serviceKeyQuery) SetResourceServiceKeyAnnotations

func (q serviceKeyQuery) SetResourceServiceKeyAnnotations(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceKeyAnnotation) error

SetResourceServiceKeyAnnotations removes all previously related items of the service_key replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceKeyAnnotations accordingly. Replaces o.R.ResourceServiceKeyAnnotations with related. Sets related.R.Resource's ResourceServiceKeyAnnotations accordingly.

func (serviceKeyQuery) SetResourceServiceKeyLabels

func (q serviceKeyQuery) SetResourceServiceKeyLabels(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceKeyLabel) error

SetResourceServiceKeyLabels removes all previously related items of the service_key replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceKeyLabels accordingly. Replaces o.R.ResourceServiceKeyLabels with related. Sets related.R.Resource's ResourceServiceKeyLabels accordingly.

func (serviceKeyQuery) SetServiceInstance

func (q serviceKeyQuery) SetServiceInstance(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceInstance) error

SetServiceInstance of the serviceKey to the related item. Sets o.R.ServiceInstance to related. Adds o to related.R.ServiceKeys.

func (serviceKeyQuery) SetServiceKeyOperation

func (q serviceKeyQuery) SetServiceKeyOperation(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceKeyOperation) error

SetServiceKeyOperation of the serviceKey to the related item. Sets o.R.ServiceKeyOperation to related. Adds o to related.R.ServiceKey.

func (serviceKeyQuery) Update

func (q serviceKeyQuery) Update(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceKey. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceKeyQuery) UpdateAll

func (q serviceKeyQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceKeyQuery) UpdateAllSlice

func (q serviceKeyQuery) UpdateAllSlice(o ServiceKeySlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceKeyQuery) Upsert

func (q serviceKeyQuery) Upsert(o *ServiceKey, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceKeyR

serviceKeyR is where relationships are stored.

type serviceKeyR struct {
    ServiceInstance               *ServiceInstance          `boil:"ServiceInstance" json:"ServiceInstance" toml:"ServiceInstance" yaml:"ServiceInstance"`
    ServiceKeyOperation           *ServiceKeyOperation      `boil:"ServiceKeyOperation" json:"ServiceKeyOperation" toml:"ServiceKeyOperation" yaml:"ServiceKeyOperation"`
    ResourceServiceKeyAnnotations ServiceKeyAnnotationSlice `boil:"ResourceServiceKeyAnnotations" json:"ResourceServiceKeyAnnotations" toml:"ResourceServiceKeyAnnotations" yaml:"ResourceServiceKeyAnnotations"`
    ResourceServiceKeyLabels      ServiceKeyLabelSlice      `boil:"ResourceServiceKeyLabels" json:"ResourceServiceKeyLabels" toml:"ResourceServiceKeyLabels" yaml:"ResourceServiceKeyLabels"`
}

func (*serviceKeyR) NewStruct

func (*serviceKeyR) NewStruct() *serviceKeyR

NewStruct creates a new relationship struct

type serviceL

serviceL is where Load methods for each relationship are stored.

type serviceL struct{}

func (serviceL) LoadResourceServiceOfferingAnnotations

func (serviceL) LoadResourceServiceOfferingAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeService interface{}, mods queries.Applicator) error

LoadResourceServiceOfferingAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceL) LoadResourceServiceOfferingLabels

func (serviceL) LoadResourceServiceOfferingLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeService interface{}, mods queries.Applicator) error

LoadResourceServiceOfferingLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (serviceL) LoadServiceBroker

func (serviceL) LoadServiceBroker(ctx context.Context, e boil.ContextExecutor, singular bool, maybeService interface{}, mods queries.Applicator) error

LoadServiceBroker allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (serviceL) LoadServicePlans

func (serviceL) LoadServicePlans(ctx context.Context, e boil.ContextExecutor, singular bool, maybeService interface{}, mods queries.Applicator) error

LoadServicePlans allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type serviceOfferingAnnotationL

serviceOfferingAnnotationL is where Load methods for each relationship are stored.

type serviceOfferingAnnotationL struct{}

func (serviceOfferingAnnotationL) LoadResource

func (serviceOfferingAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceOfferingAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceOfferingAnnotationQuery

type serviceOfferingAnnotationQuery struct {
    *queries.Query
}

func ServiceOfferingAnnotations

func ServiceOfferingAnnotations(mods ...qm.QueryMod) serviceOfferingAnnotationQuery

ServiceOfferingAnnotations retrieves all the records using an executor.

func (serviceOfferingAnnotationQuery) All

func (q serviceOfferingAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceOfferingAnnotationSlice, error)

All returns all ServiceOfferingAnnotation records from the query.

func (serviceOfferingAnnotationQuery) Count

func (q serviceOfferingAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceOfferingAnnotation records in the query.

func (serviceOfferingAnnotationQuery) Delete

func (q serviceOfferingAnnotationQuery) Delete(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceOfferingAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceOfferingAnnotationQuery) DeleteAll

func (q serviceOfferingAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceOfferingAnnotationQuery) DeleteAllSlice

func (q serviceOfferingAnnotationQuery) DeleteAllSlice(o ServiceOfferingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceOfferingAnnotationQuery) Exists

func (q serviceOfferingAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceOfferingAnnotationQuery) Insert

func (q serviceOfferingAnnotationQuery) Insert(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceOfferingAnnotationQuery) One

func (q serviceOfferingAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceOfferingAnnotation, error)

One returns a single serviceOfferingAnnotation record from the query.

func (serviceOfferingAnnotationQuery) Reload

func (q serviceOfferingAnnotationQuery) Reload(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceOfferingAnnotationQuery) ReloadAll

func (q serviceOfferingAnnotationQuery) ReloadAll(o *ServiceOfferingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceOfferingAnnotationQuery) RemoveResource

func (q serviceOfferingAnnotationQuery) RemoveResource(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Service) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceOfferingAnnotationQuery) Resource

func (q serviceOfferingAnnotationQuery) Resource(o *ServiceOfferingAnnotation, mods ...qm.QueryMod) serviceQuery

Resource pointed to by the foreign key.

func (serviceOfferingAnnotationQuery) SetResource

func (q serviceOfferingAnnotationQuery) SetResource(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Service) error

SetResource of the serviceOfferingAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceOfferingAnnotations.

func (serviceOfferingAnnotationQuery) Update

func (q serviceOfferingAnnotationQuery) Update(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceOfferingAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceOfferingAnnotationQuery) UpdateAll

func (q serviceOfferingAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceOfferingAnnotationQuery) UpdateAllSlice

func (q serviceOfferingAnnotationQuery) UpdateAllSlice(o ServiceOfferingAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceOfferingAnnotationQuery) Upsert

func (q serviceOfferingAnnotationQuery) Upsert(o *ServiceOfferingAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceOfferingAnnotationR

serviceOfferingAnnotationR is where relationships are stored.

type serviceOfferingAnnotationR struct {
    Resource *Service `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceOfferingAnnotationR) NewStruct

func (*serviceOfferingAnnotationR) NewStruct() *serviceOfferingAnnotationR

NewStruct creates a new relationship struct

type serviceOfferingLabelL

serviceOfferingLabelL is where Load methods for each relationship are stored.

type serviceOfferingLabelL struct{}

func (serviceOfferingLabelL) LoadResource

func (serviceOfferingLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServiceOfferingLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type serviceOfferingLabelQuery

type serviceOfferingLabelQuery struct {
    *queries.Query
}

func ServiceOfferingLabels

func ServiceOfferingLabels(mods ...qm.QueryMod) serviceOfferingLabelQuery

ServiceOfferingLabels retrieves all the records using an executor.

func (serviceOfferingLabelQuery) All

func (q serviceOfferingLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceOfferingLabelSlice, error)

All returns all ServiceOfferingLabel records from the query.

func (serviceOfferingLabelQuery) Count

func (q serviceOfferingLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceOfferingLabel records in the query.

func (serviceOfferingLabelQuery) Delete

func (q serviceOfferingLabelQuery) Delete(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceOfferingLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceOfferingLabelQuery) DeleteAll

func (q serviceOfferingLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceOfferingLabelQuery) DeleteAllSlice

func (q serviceOfferingLabelQuery) DeleteAllSlice(o ServiceOfferingLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceOfferingLabelQuery) Exists

func (q serviceOfferingLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceOfferingLabelQuery) Insert

func (q serviceOfferingLabelQuery) Insert(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceOfferingLabelQuery) One

func (q serviceOfferingLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceOfferingLabel, error)

One returns a single serviceOfferingLabel record from the query.

func (serviceOfferingLabelQuery) Reload

func (q serviceOfferingLabelQuery) Reload(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceOfferingLabelQuery) ReloadAll

func (q serviceOfferingLabelQuery) ReloadAll(o *ServiceOfferingLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceOfferingLabelQuery) RemoveResource

func (q serviceOfferingLabelQuery) RemoveResource(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor, related *Service) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceOfferingLabelQuery) Resource

func (q serviceOfferingLabelQuery) Resource(o *ServiceOfferingLabel, mods ...qm.QueryMod) serviceQuery

Resource pointed to by the foreign key.

func (serviceOfferingLabelQuery) SetResource

func (q serviceOfferingLabelQuery) SetResource(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Service) error

SetResource of the serviceOfferingLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServiceOfferingLabels.

func (serviceOfferingLabelQuery) Update

func (q serviceOfferingLabelQuery) Update(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceOfferingLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceOfferingLabelQuery) UpdateAll

func (q serviceOfferingLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceOfferingLabelQuery) UpdateAllSlice

func (q serviceOfferingLabelQuery) UpdateAllSlice(o ServiceOfferingLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceOfferingLabelQuery) Upsert

func (q serviceOfferingLabelQuery) Upsert(o *ServiceOfferingLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceOfferingLabelR

serviceOfferingLabelR is where relationships are stored.

type serviceOfferingLabelR struct {
    Resource *Service `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*serviceOfferingLabelR) NewStruct

func (*serviceOfferingLabelR) NewStruct() *serviceOfferingLabelR

NewStruct creates a new relationship struct

type servicePlanAnnotationL

servicePlanAnnotationL is where Load methods for each relationship are stored.

type servicePlanAnnotationL struct{}

func (servicePlanAnnotationL) LoadResource

func (servicePlanAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServicePlanAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type servicePlanAnnotationQuery

type servicePlanAnnotationQuery struct {
    *queries.Query
}

func ServicePlanAnnotations

func ServicePlanAnnotations(mods ...qm.QueryMod) servicePlanAnnotationQuery

ServicePlanAnnotations retrieves all the records using an executor.

func (servicePlanAnnotationQuery) All

func (q servicePlanAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServicePlanAnnotationSlice, error)

All returns all ServicePlanAnnotation records from the query.

func (servicePlanAnnotationQuery) Count

func (q servicePlanAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServicePlanAnnotation records in the query.

func (servicePlanAnnotationQuery) Delete

func (q servicePlanAnnotationQuery) Delete(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServicePlanAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (servicePlanAnnotationQuery) DeleteAll

func (q servicePlanAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (servicePlanAnnotationQuery) DeleteAllSlice

func (q servicePlanAnnotationQuery) DeleteAllSlice(o ServicePlanAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (servicePlanAnnotationQuery) Exists

func (q servicePlanAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (servicePlanAnnotationQuery) Insert

func (q servicePlanAnnotationQuery) Insert(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (servicePlanAnnotationQuery) One

func (q servicePlanAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServicePlanAnnotation, error)

One returns a single servicePlanAnnotation record from the query.

func (servicePlanAnnotationQuery) Reload

func (q servicePlanAnnotationQuery) Reload(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (servicePlanAnnotationQuery) ReloadAll

func (q servicePlanAnnotationQuery) ReloadAll(o *ServicePlanAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (servicePlanAnnotationQuery) RemoveResource

func (q servicePlanAnnotationQuery) RemoveResource(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor, related *ServicePlan) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (servicePlanAnnotationQuery) Resource

func (q servicePlanAnnotationQuery) Resource(o *ServicePlanAnnotation, mods ...qm.QueryMod) servicePlanQuery

Resource pointed to by the foreign key.

func (servicePlanAnnotationQuery) SetResource

func (q servicePlanAnnotationQuery) SetResource(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServicePlan) error

SetResource of the servicePlanAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServicePlanAnnotations.

func (servicePlanAnnotationQuery) Update

func (q servicePlanAnnotationQuery) Update(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServicePlanAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (servicePlanAnnotationQuery) UpdateAll

func (q servicePlanAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (servicePlanAnnotationQuery) UpdateAllSlice

func (q servicePlanAnnotationQuery) UpdateAllSlice(o ServicePlanAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (servicePlanAnnotationQuery) Upsert

func (q servicePlanAnnotationQuery) Upsert(o *ServicePlanAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type servicePlanAnnotationR

servicePlanAnnotationR is where relationships are stored.

type servicePlanAnnotationR struct {
    Resource *ServicePlan `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*servicePlanAnnotationR) NewStruct

func (*servicePlanAnnotationR) NewStruct() *servicePlanAnnotationR

NewStruct creates a new relationship struct

type servicePlanL

servicePlanL is where Load methods for each relationship are stored.

type servicePlanL struct{}

func (servicePlanL) LoadResourceServicePlanAnnotations

func (servicePlanL) LoadResourceServicePlanAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServicePlan interface{}, mods queries.Applicator) error

LoadResourceServicePlanAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (servicePlanL) LoadResourceServicePlanLabels

func (servicePlanL) LoadResourceServicePlanLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServicePlan interface{}, mods queries.Applicator) error

LoadResourceServicePlanLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (servicePlanL) LoadService

func (servicePlanL) LoadService(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServicePlan interface{}, mods queries.Applicator) error

LoadService allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (servicePlanL) LoadServiceInstances

func (servicePlanL) LoadServiceInstances(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServicePlan interface{}, mods queries.Applicator) error

LoadServiceInstances allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (servicePlanL) LoadServicePlanVisibilities

func (servicePlanL) LoadServicePlanVisibilities(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServicePlan interface{}, mods queries.Applicator) error

LoadServicePlanVisibilities allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type servicePlanLabelL

servicePlanLabelL is where Load methods for each relationship are stored.

type servicePlanLabelL struct{}

func (servicePlanLabelL) LoadResource

func (servicePlanLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServicePlanLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type servicePlanLabelQuery

type servicePlanLabelQuery struct {
    *queries.Query
}

func ServicePlanLabels

func ServicePlanLabels(mods ...qm.QueryMod) servicePlanLabelQuery

ServicePlanLabels retrieves all the records using an executor.

func (servicePlanLabelQuery) All

func (q servicePlanLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServicePlanLabelSlice, error)

All returns all ServicePlanLabel records from the query.

func (servicePlanLabelQuery) Count

func (q servicePlanLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServicePlanLabel records in the query.

func (servicePlanLabelQuery) Delete

func (q servicePlanLabelQuery) Delete(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServicePlanLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (servicePlanLabelQuery) DeleteAll

func (q servicePlanLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (servicePlanLabelQuery) DeleteAllSlice

func (q servicePlanLabelQuery) DeleteAllSlice(o ServicePlanLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (servicePlanLabelQuery) Exists

func (q servicePlanLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (servicePlanLabelQuery) Insert

func (q servicePlanLabelQuery) Insert(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (servicePlanLabelQuery) One

func (q servicePlanLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServicePlanLabel, error)

One returns a single servicePlanLabel record from the query.

func (servicePlanLabelQuery) Reload

func (q servicePlanLabelQuery) Reload(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (servicePlanLabelQuery) ReloadAll

func (q servicePlanLabelQuery) ReloadAll(o *ServicePlanLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (servicePlanLabelQuery) RemoveResource

func (q servicePlanLabelQuery) RemoveResource(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor, related *ServicePlan) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (servicePlanLabelQuery) Resource

func (q servicePlanLabelQuery) Resource(o *ServicePlanLabel, mods ...qm.QueryMod) servicePlanQuery

Resource pointed to by the foreign key.

func (servicePlanLabelQuery) SetResource

func (q servicePlanLabelQuery) SetResource(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServicePlan) error

SetResource of the servicePlanLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceServicePlanLabels.

func (servicePlanLabelQuery) Update

func (q servicePlanLabelQuery) Update(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServicePlanLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (servicePlanLabelQuery) UpdateAll

func (q servicePlanLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (servicePlanLabelQuery) UpdateAllSlice

func (q servicePlanLabelQuery) UpdateAllSlice(o ServicePlanLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (servicePlanLabelQuery) Upsert

func (q servicePlanLabelQuery) Upsert(o *ServicePlanLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type servicePlanLabelR

servicePlanLabelR is where relationships are stored.

type servicePlanLabelR struct {
    Resource *ServicePlan `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*servicePlanLabelR) NewStruct

func (*servicePlanLabelR) NewStruct() *servicePlanLabelR

NewStruct creates a new relationship struct

type servicePlanQuery

type servicePlanQuery struct {
    *queries.Query
}

func ServicePlans

func ServicePlans(mods ...qm.QueryMod) servicePlanQuery

ServicePlans retrieves all the records using an executor.

func (servicePlanQuery) AddResourceServicePlanAnnotations

func (q servicePlanQuery) AddResourceServicePlanAnnotations(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServicePlanAnnotation) error

AddResourceServicePlanAnnotations adds the given related objects to the existing relationships of the service_plan\, optionally inserting them as new records. Appends related to o.R.ResourceServicePlanAnnotations. Sets related.R.Resource appropriately.

func (servicePlanQuery) AddResourceServicePlanLabels

func (q servicePlanQuery) AddResourceServicePlanLabels(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServicePlanLabel) error

AddResourceServicePlanLabels adds the given related objects to the existing relationships of the service_plan\, optionally inserting them as new records. Appends related to o.R.ResourceServicePlanLabels. Sets related.R.Resource appropriately.

func (servicePlanQuery) AddServiceInstances

func (q servicePlanQuery) AddServiceInstances(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceInstance) error

AddServiceInstances adds the given related objects to the existing relationships of the service_plan\, optionally inserting them as new records. Appends related to o.R.ServiceInstances. Sets related.R.ServicePlan appropriately.

func (servicePlanQuery) AddServicePlanVisibilities

func (q servicePlanQuery) AddServicePlanVisibilities(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServicePlanVisibility) error

AddServicePlanVisibilities adds the given related objects to the existing relationships of the service_plan\, optionally inserting them as new records. Appends related to o.R.ServicePlanVisibilities. Sets related.R.ServicePlan appropriately.

func (servicePlanQuery) All

func (q servicePlanQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServicePlanSlice, error)

All returns all ServicePlan records from the query.

func (servicePlanQuery) Count

func (q servicePlanQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServicePlan records in the query.

func (servicePlanQuery) Delete

func (q servicePlanQuery) Delete(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServicePlan record with an executor. Delete will match against the primary key column to find the record to delete.

func (servicePlanQuery) DeleteAll

func (q servicePlanQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (servicePlanQuery) DeleteAllSlice

func (q servicePlanQuery) DeleteAllSlice(o ServicePlanSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (servicePlanQuery) Exists

func (q servicePlanQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (servicePlanQuery) Insert

func (q servicePlanQuery) Insert(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (servicePlanQuery) One

func (q servicePlanQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServicePlan, error)

One returns a single servicePlan record from the query.

func (servicePlanQuery) Reload

func (q servicePlanQuery) Reload(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (servicePlanQuery) ReloadAll

func (q servicePlanQuery) ReloadAll(o *ServicePlanSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (servicePlanQuery) RemoveResourceServicePlanAnnotations

func (q servicePlanQuery) RemoveResourceServicePlanAnnotations(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, related ...*ServicePlanAnnotation) error

RemoveResourceServicePlanAnnotations relationships from objects passed in. Removes related items from R.ResourceServicePlanAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (servicePlanQuery) RemoveResourceServicePlanLabels

func (q servicePlanQuery) RemoveResourceServicePlanLabels(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, related ...*ServicePlanLabel) error

RemoveResourceServicePlanLabels relationships from objects passed in. Removes related items from R.ResourceServicePlanLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (servicePlanQuery) RemoveServiceInstances

func (q servicePlanQuery) RemoveServiceInstances(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceInstance) error

RemoveServiceInstances relationships from objects passed in. Removes related items from R.ServiceInstances (uses pointer comparison\, removal does not keep order) Sets related.R.ServicePlan.

func (servicePlanQuery) ResourceServicePlanAnnotations

func (q servicePlanQuery) ResourceServicePlanAnnotations(o *ServicePlan, mods ...qm.QueryMod) servicePlanAnnotationQuery

ResourceServicePlanAnnotations retrieves all the service_plan_annotation's ServicePlanAnnotations with an executor via resource_guid column.

func (servicePlanQuery) ResourceServicePlanLabels

func (q servicePlanQuery) ResourceServicePlanLabels(o *ServicePlan, mods ...qm.QueryMod) servicePlanLabelQuery

ResourceServicePlanLabels retrieves all the service_plan_label's ServicePlanLabels with an executor via resource_guid column.

func (servicePlanQuery) Service

func (q servicePlanQuery) Service(o *ServicePlan, mods ...qm.QueryMod) serviceQuery

Service pointed to by the foreign key.

func (servicePlanQuery) ServiceInstances

func (q servicePlanQuery) ServiceInstances(o *ServicePlan, mods ...qm.QueryMod) serviceInstanceQuery

ServiceInstances retrieves all the service_instance's ServiceInstances with an executor.

func (servicePlanQuery) ServicePlanVisibilities

func (q servicePlanQuery) ServicePlanVisibilities(o *ServicePlan, mods ...qm.QueryMod) servicePlanVisibilityQuery

ServicePlanVisibilities retrieves all the service_plan_visibility's ServicePlanVisibilities with an executor.

func (servicePlanQuery) SetResourceServicePlanAnnotations

func (q servicePlanQuery) SetResourceServicePlanAnnotations(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServicePlanAnnotation) error

SetResourceServicePlanAnnotations removes all previously related items of the service_plan replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServicePlanAnnotations accordingly. Replaces o.R.ResourceServicePlanAnnotations with related. Sets related.R.Resource's ResourceServicePlanAnnotations accordingly.

func (servicePlanQuery) SetResourceServicePlanLabels

func (q servicePlanQuery) SetResourceServicePlanLabels(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServicePlanLabel) error

SetResourceServicePlanLabels removes all previously related items of the service_plan replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServicePlanLabels accordingly. Replaces o.R.ResourceServicePlanLabels with related. Sets related.R.Resource's ResourceServicePlanLabels accordingly.

func (servicePlanQuery) SetService

func (q servicePlanQuery) SetService(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Service) error

SetService of the servicePlan to the related item. Sets o.R.Service to related. Adds o to related.R.ServicePlans.

func (servicePlanQuery) SetServiceInstances

func (q servicePlanQuery) SetServiceInstances(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceInstance) error

SetServiceInstances removes all previously related items of the service_plan replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.ServicePlan's ServiceInstances accordingly. Replaces o.R.ServiceInstances with related. Sets related.R.ServicePlan's ServiceInstances accordingly.

func (servicePlanQuery) Update

func (q servicePlanQuery) Update(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServicePlan. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (servicePlanQuery) UpdateAll

func (q servicePlanQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (servicePlanQuery) UpdateAllSlice

func (q servicePlanQuery) UpdateAllSlice(o ServicePlanSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (servicePlanQuery) Upsert

func (q servicePlanQuery) Upsert(o *ServicePlan, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type servicePlanR

servicePlanR is where relationships are stored.

type servicePlanR struct {
    Service                        *Service                   `boil:"Service" json:"Service" toml:"Service" yaml:"Service"`
    ServiceInstances               ServiceInstanceSlice       `boil:"ServiceInstances" json:"ServiceInstances" toml:"ServiceInstances" yaml:"ServiceInstances"`
    ResourceServicePlanAnnotations ServicePlanAnnotationSlice `boil:"ResourceServicePlanAnnotations" json:"ResourceServicePlanAnnotations" toml:"ResourceServicePlanAnnotations" yaml:"ResourceServicePlanAnnotations"`
    ResourceServicePlanLabels      ServicePlanLabelSlice      `boil:"ResourceServicePlanLabels" json:"ResourceServicePlanLabels" toml:"ResourceServicePlanLabels" yaml:"ResourceServicePlanLabels"`
    ServicePlanVisibilities        ServicePlanVisibilitySlice `boil:"ServicePlanVisibilities" json:"ServicePlanVisibilities" toml:"ServicePlanVisibilities" yaml:"ServicePlanVisibilities"`
}

func (*servicePlanR) NewStruct

func (*servicePlanR) NewStruct() *servicePlanR

NewStruct creates a new relationship struct

type servicePlanVisibilityL

servicePlanVisibilityL is where Load methods for each relationship are stored.

type servicePlanVisibilityL struct{}

func (servicePlanVisibilityL) LoadOrganization

func (servicePlanVisibilityL) LoadOrganization(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServicePlanVisibility interface{}, mods queries.Applicator) error

LoadOrganization allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (servicePlanVisibilityL) LoadServicePlan

func (servicePlanVisibilityL) LoadServicePlan(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServicePlanVisibility interface{}, mods queries.Applicator) error

LoadServicePlan allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type servicePlanVisibilityQuery

type servicePlanVisibilityQuery struct {
    *queries.Query
}

func ServicePlanVisibilities

func ServicePlanVisibilities(mods ...qm.QueryMod) servicePlanVisibilityQuery

ServicePlanVisibilities retrieves all the records using an executor.

func (servicePlanVisibilityQuery) All

func (q servicePlanVisibilityQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServicePlanVisibilitySlice, error)

All returns all ServicePlanVisibility records from the query.

func (servicePlanVisibilityQuery) Count

func (q servicePlanVisibilityQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServicePlanVisibility records in the query.

func (servicePlanVisibilityQuery) Delete

func (q servicePlanVisibilityQuery) Delete(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServicePlanVisibility record with an executor. Delete will match against the primary key column to find the record to delete.

func (servicePlanVisibilityQuery) DeleteAll

func (q servicePlanVisibilityQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (servicePlanVisibilityQuery) DeleteAllSlice

func (q servicePlanVisibilityQuery) DeleteAllSlice(o ServicePlanVisibilitySlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (servicePlanVisibilityQuery) Exists

func (q servicePlanVisibilityQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (servicePlanVisibilityQuery) Insert

func (q servicePlanVisibilityQuery) Insert(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (servicePlanVisibilityQuery) One

func (q servicePlanVisibilityQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServicePlanVisibility, error)

One returns a single servicePlanVisibility record from the query.

func (servicePlanVisibilityQuery) Organization

func (q servicePlanVisibilityQuery) Organization(o *ServicePlanVisibility, mods ...qm.QueryMod) organizationQuery

Organization pointed to by the foreign key.

func (servicePlanVisibilityQuery) Reload

func (q servicePlanVisibilityQuery) Reload(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (servicePlanVisibilityQuery) ReloadAll

func (q servicePlanVisibilityQuery) ReloadAll(o *ServicePlanVisibilitySlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (servicePlanVisibilityQuery) ServicePlan

func (q servicePlanVisibilityQuery) ServicePlan(o *ServicePlanVisibility, mods ...qm.QueryMod) servicePlanQuery

ServicePlan pointed to by the foreign key.

func (servicePlanVisibilityQuery) SetOrganization

func (q servicePlanVisibilityQuery) SetOrganization(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Organization) error

SetOrganization of the servicePlanVisibility to the related item. Sets o.R.Organization to related. Adds o to related.R.ServicePlanVisibilities.

func (servicePlanVisibilityQuery) SetServicePlan

func (q servicePlanVisibilityQuery) SetServicePlan(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServicePlan) error

SetServicePlan of the servicePlanVisibility to the related item. Sets o.R.ServicePlan to related. Adds o to related.R.ServicePlanVisibilities.

func (servicePlanVisibilityQuery) Update

func (q servicePlanVisibilityQuery) Update(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServicePlanVisibility. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (servicePlanVisibilityQuery) UpdateAll

func (q servicePlanVisibilityQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (servicePlanVisibilityQuery) UpdateAllSlice

func (q servicePlanVisibilityQuery) UpdateAllSlice(o ServicePlanVisibilitySlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (servicePlanVisibilityQuery) Upsert

func (q servicePlanVisibilityQuery) Upsert(o *ServicePlanVisibility, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type servicePlanVisibilityR

servicePlanVisibilityR is where relationships are stored.

type servicePlanVisibilityR struct {
    Organization *Organization `boil:"Organization" json:"Organization" toml:"Organization" yaml:"Organization"`
    ServicePlan  *ServicePlan  `boil:"ServicePlan" json:"ServicePlan" toml:"ServicePlan" yaml:"ServicePlan"`
}

func (*servicePlanVisibilityR) NewStruct

func (*servicePlanVisibilityR) NewStruct() *servicePlanVisibilityR

NewStruct creates a new relationship struct

type serviceQuery

type serviceQuery struct {
    *queries.Query
}

func Services

func Services(mods ...qm.QueryMod) serviceQuery

Services retrieves all the records using an executor.

func (serviceQuery) AddResourceServiceOfferingAnnotations

func (q serviceQuery) AddResourceServiceOfferingAnnotations(o *Service, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceOfferingAnnotation) error

AddResourceServiceOfferingAnnotations adds the given related objects to the existing relationships of the service\, optionally inserting them as new records. Appends related to o.R.ResourceServiceOfferingAnnotations. Sets related.R.Resource appropriately.

func (serviceQuery) AddResourceServiceOfferingLabels

func (q serviceQuery) AddResourceServiceOfferingLabels(o *Service, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceOfferingLabel) error

AddResourceServiceOfferingLabels adds the given related objects to the existing relationships of the service\, optionally inserting them as new records. Appends related to o.R.ResourceServiceOfferingLabels. Sets related.R.Resource appropriately.

func (serviceQuery) AddServicePlans

func (q serviceQuery) AddServicePlans(o *Service, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServicePlan) error

AddServicePlans adds the given related objects to the existing relationships of the service\, optionally inserting them as new records. Appends related to o.R.ServicePlans. Sets related.R.Service appropriately.

func (serviceQuery) All

func (q serviceQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceSlice, error)

All returns all Service records from the query.

func (serviceQuery) Count

func (q serviceQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Service records in the query.

func (serviceQuery) Delete

func (q serviceQuery) Delete(o *Service, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Service record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceQuery) DeleteAll

func (q serviceQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceQuery) DeleteAllSlice

func (q serviceQuery) DeleteAllSlice(o ServiceSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceQuery) Exists

func (q serviceQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceQuery) Insert

func (q serviceQuery) Insert(o *Service, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceQuery) One

func (q serviceQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Service, error)

One returns a single service record from the query.

func (serviceQuery) Reload

func (q serviceQuery) Reload(o *Service, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceQuery) ReloadAll

func (q serviceQuery) ReloadAll(o *ServiceSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceQuery) RemoveResourceServiceOfferingAnnotations

func (q serviceQuery) RemoveResourceServiceOfferingAnnotations(o *Service, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceOfferingAnnotation) error

RemoveResourceServiceOfferingAnnotations relationships from objects passed in. Removes related items from R.ResourceServiceOfferingAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceQuery) RemoveResourceServiceOfferingLabels

func (q serviceQuery) RemoveResourceServiceOfferingLabels(o *Service, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceOfferingLabel) error

RemoveResourceServiceOfferingLabels relationships from objects passed in. Removes related items from R.ResourceServiceOfferingLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (serviceQuery) RemoveServiceBroker

func (q serviceQuery) RemoveServiceBroker(o *Service, ctx context.Context, exec boil.ContextExecutor, related *ServiceBroker) error

RemoveServiceBroker relationship. Sets o.R.ServiceBroker to nil. Removes o from all passed in related items' relationships struct (Optional).

func (serviceQuery) ResourceServiceOfferingAnnotations

func (q serviceQuery) ResourceServiceOfferingAnnotations(o *Service, mods ...qm.QueryMod) serviceOfferingAnnotationQuery

ResourceServiceOfferingAnnotations retrieves all the service_offering_annotation's ServiceOfferingAnnotations with an executor via resource_guid column.

func (serviceQuery) ResourceServiceOfferingLabels

func (q serviceQuery) ResourceServiceOfferingLabels(o *Service, mods ...qm.QueryMod) serviceOfferingLabelQuery

ResourceServiceOfferingLabels retrieves all the service_offering_label's ServiceOfferingLabels with an executor via resource_guid column.

func (serviceQuery) ServiceBroker

func (q serviceQuery) ServiceBroker(o *Service, mods ...qm.QueryMod) serviceBrokerQuery

ServiceBroker pointed to by the foreign key.

func (serviceQuery) ServicePlans

func (q serviceQuery) ServicePlans(o *Service, mods ...qm.QueryMod) servicePlanQuery

ServicePlans retrieves all the service_plan's ServicePlans with an executor.

func (serviceQuery) SetResourceServiceOfferingAnnotations

func (q serviceQuery) SetResourceServiceOfferingAnnotations(o *Service, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceOfferingAnnotation) error

SetResourceServiceOfferingAnnotations removes all previously related items of the service replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceOfferingAnnotations accordingly. Replaces o.R.ResourceServiceOfferingAnnotations with related. Sets related.R.Resource's ResourceServiceOfferingAnnotations accordingly.

func (serviceQuery) SetResourceServiceOfferingLabels

func (q serviceQuery) SetResourceServiceOfferingLabels(o *Service, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceOfferingLabel) error

SetResourceServiceOfferingLabels removes all previously related items of the service replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceServiceOfferingLabels accordingly. Replaces o.R.ResourceServiceOfferingLabels with related. Sets related.R.Resource's ResourceServiceOfferingLabels accordingly.

func (serviceQuery) SetServiceBroker

func (q serviceQuery) SetServiceBroker(o *Service, ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServiceBroker) error

SetServiceBroker of the service to the related item. Sets o.R.ServiceBroker to related. Adds o to related.R.Services.

func (serviceQuery) Update

func (q serviceQuery) Update(o *Service, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Service. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceQuery) UpdateAll

func (q serviceQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceQuery) UpdateAllSlice

func (q serviceQuery) UpdateAllSlice(o ServiceSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceQuery) Upsert

func (q serviceQuery) Upsert(o *Service, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceR

serviceR is where relationships are stored.

type serviceR struct {
    ServiceBroker                      *ServiceBroker                 `boil:"ServiceBroker" json:"ServiceBroker" toml:"ServiceBroker" yaml:"ServiceBroker"`
    ResourceServiceOfferingAnnotations ServiceOfferingAnnotationSlice `boil:"ResourceServiceOfferingAnnotations" json:"ResourceServiceOfferingAnnotations" toml:"ResourceServiceOfferingAnnotations" yaml:"ResourceServiceOfferingAnnotations"`
    ResourceServiceOfferingLabels      ServiceOfferingLabelSlice      `boil:"ResourceServiceOfferingLabels" json:"ResourceServiceOfferingLabels" toml:"ResourceServiceOfferingLabels" yaml:"ResourceServiceOfferingLabels"`
    ServicePlans                       ServicePlanSlice               `boil:"ServicePlans" json:"ServicePlans" toml:"ServicePlans" yaml:"ServicePlans"`
}

func (*serviceR) NewStruct

func (*serviceR) NewStruct() *serviceR

NewStruct creates a new relationship struct

type serviceUsageEventL

serviceUsageEventL is where Load methods for each relationship are stored.

type serviceUsageEventL struct{}

type serviceUsageEventQuery

type serviceUsageEventQuery struct {
    *queries.Query
}

func ServiceUsageEvents

func ServiceUsageEvents(mods ...qm.QueryMod) serviceUsageEventQuery

ServiceUsageEvents retrieves all the records using an executor.

func (serviceUsageEventQuery) All

func (q serviceUsageEventQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServiceUsageEventSlice, error)

All returns all ServiceUsageEvent records from the query.

func (serviceUsageEventQuery) Count

func (q serviceUsageEventQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all ServiceUsageEvent records in the query.

func (serviceUsageEventQuery) Delete

func (q serviceUsageEventQuery) Delete(o *ServiceUsageEvent, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single ServiceUsageEvent record with an executor. Delete will match against the primary key column to find the record to delete.

func (serviceUsageEventQuery) DeleteAll

func (q serviceUsageEventQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (serviceUsageEventQuery) DeleteAllSlice

func (q serviceUsageEventQuery) DeleteAllSlice(o ServiceUsageEventSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (serviceUsageEventQuery) Exists

func (q serviceUsageEventQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (serviceUsageEventQuery) Insert

func (q serviceUsageEventQuery) Insert(o *ServiceUsageEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (serviceUsageEventQuery) One

func (q serviceUsageEventQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServiceUsageEvent, error)

One returns a single serviceUsageEvent record from the query.

func (serviceUsageEventQuery) Reload

func (q serviceUsageEventQuery) Reload(o *ServiceUsageEvent, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (serviceUsageEventQuery) ReloadAll

func (q serviceUsageEventQuery) ReloadAll(o *ServiceUsageEventSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (serviceUsageEventQuery) Update

func (q serviceUsageEventQuery) Update(o *ServiceUsageEvent, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the ServiceUsageEvent. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (serviceUsageEventQuery) UpdateAll

func (q serviceUsageEventQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (serviceUsageEventQuery) UpdateAllSlice

func (q serviceUsageEventQuery) UpdateAllSlice(o ServiceUsageEventSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (serviceUsageEventQuery) Upsert

func (q serviceUsageEventQuery) Upsert(o *ServiceUsageEvent, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type serviceUsageEventR

serviceUsageEventR is where relationships are stored.

type serviceUsageEventR struct {
}

func (*serviceUsageEventR) NewStruct

func (*serviceUsageEventR) NewStruct() *serviceUsageEventR

NewStruct creates a new relationship struct

type sidecarL

sidecarL is where Load methods for each relationship are stored.

type sidecarL struct{}

func (sidecarL) LoadApp

func (sidecarL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSidecar interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (sidecarL) LoadSidecarProcessTypes

func (sidecarL) LoadSidecarProcessTypes(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSidecar interface{}, mods queries.Applicator) error

LoadSidecarProcessTypes allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type sidecarProcessTypeL

sidecarProcessTypeL is where Load methods for each relationship are stored.

type sidecarProcessTypeL struct{}

func (sidecarProcessTypeL) LoadSidecar

func (sidecarProcessTypeL) LoadSidecar(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSidecarProcessType interface{}, mods queries.Applicator) error

LoadSidecar allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type sidecarProcessTypeQuery

type sidecarProcessTypeQuery struct {
    *queries.Query
}

func SidecarProcessTypes

func SidecarProcessTypes(mods ...qm.QueryMod) sidecarProcessTypeQuery

SidecarProcessTypes retrieves all the records using an executor.

func (sidecarProcessTypeQuery) All

func (q sidecarProcessTypeQuery) All(ctx context.Context, exec boil.ContextExecutor) (SidecarProcessTypeSlice, error)

All returns all SidecarProcessType records from the query.

func (sidecarProcessTypeQuery) Count

func (q sidecarProcessTypeQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all SidecarProcessType records in the query.

func (sidecarProcessTypeQuery) Delete

func (q sidecarProcessTypeQuery) Delete(o *SidecarProcessType, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single SidecarProcessType record with an executor. Delete will match against the primary key column to find the record to delete.

func (sidecarProcessTypeQuery) DeleteAll

func (q sidecarProcessTypeQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (sidecarProcessTypeQuery) DeleteAllSlice

func (q sidecarProcessTypeQuery) DeleteAllSlice(o SidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (sidecarProcessTypeQuery) Exists

func (q sidecarProcessTypeQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (sidecarProcessTypeQuery) Insert

func (q sidecarProcessTypeQuery) Insert(o *SidecarProcessType, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (sidecarProcessTypeQuery) One

func (q sidecarProcessTypeQuery) One(ctx context.Context, exec boil.ContextExecutor) (*SidecarProcessType, error)

One returns a single sidecarProcessType record from the query.

func (sidecarProcessTypeQuery) Reload

func (q sidecarProcessTypeQuery) Reload(o *SidecarProcessType, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (sidecarProcessTypeQuery) ReloadAll

func (q sidecarProcessTypeQuery) ReloadAll(o *SidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (sidecarProcessTypeQuery) SetSidecar

func (q sidecarProcessTypeQuery) SetSidecar(o *SidecarProcessType, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Sidecar) error

SetSidecar of the sidecarProcessType to the related item. Sets o.R.Sidecar to related. Adds o to related.R.SidecarProcessTypes.

func (sidecarProcessTypeQuery) Sidecar

func (q sidecarProcessTypeQuery) Sidecar(o *SidecarProcessType, mods ...qm.QueryMod) sidecarQuery

Sidecar pointed to by the foreign key.

func (sidecarProcessTypeQuery) Update

func (q sidecarProcessTypeQuery) Update(o *SidecarProcessType, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the SidecarProcessType. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (sidecarProcessTypeQuery) UpdateAll

func (q sidecarProcessTypeQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (sidecarProcessTypeQuery) UpdateAllSlice

func (q sidecarProcessTypeQuery) UpdateAllSlice(o SidecarProcessTypeSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (sidecarProcessTypeQuery) Upsert

func (q sidecarProcessTypeQuery) Upsert(o *SidecarProcessType, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type sidecarProcessTypeR

sidecarProcessTypeR is where relationships are stored.

type sidecarProcessTypeR struct {
    Sidecar *Sidecar `boil:"Sidecar" json:"Sidecar" toml:"Sidecar" yaml:"Sidecar"`
}

func (*sidecarProcessTypeR) NewStruct

func (*sidecarProcessTypeR) NewStruct() *sidecarProcessTypeR

NewStruct creates a new relationship struct

type sidecarQuery

type sidecarQuery struct {
    *queries.Query
}

func Sidecars

func Sidecars(mods ...qm.QueryMod) sidecarQuery

Sidecars retrieves all the records using an executor.

func (sidecarQuery) AddSidecarProcessTypes

func (q sidecarQuery) AddSidecarProcessTypes(o *Sidecar, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SidecarProcessType) error

AddSidecarProcessTypes adds the given related objects to the existing relationships of the sidecar\, optionally inserting them as new records. Appends related to o.R.SidecarProcessTypes. Sets related.R.Sidecar appropriately.

func (sidecarQuery) All

func (q sidecarQuery) All(ctx context.Context, exec boil.ContextExecutor) (SidecarSlice, error)

All returns all Sidecar records from the query.

func (sidecarQuery) App

func (q sidecarQuery) App(o *Sidecar, mods ...qm.QueryMod) appQuery

App pointed to by the foreign key.

func (sidecarQuery) Count

func (q sidecarQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Sidecar records in the query.

func (sidecarQuery) Delete

func (q sidecarQuery) Delete(o *Sidecar, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Sidecar record with an executor. Delete will match against the primary key column to find the record to delete.

func (sidecarQuery) DeleteAll

func (q sidecarQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (sidecarQuery) DeleteAllSlice

func (q sidecarQuery) DeleteAllSlice(o SidecarSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (sidecarQuery) Exists

func (q sidecarQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (sidecarQuery) Insert

func (q sidecarQuery) Insert(o *Sidecar, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (sidecarQuery) One

func (q sidecarQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Sidecar, error)

One returns a single sidecar record from the query.

func (sidecarQuery) Reload

func (q sidecarQuery) Reload(o *Sidecar, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (sidecarQuery) ReloadAll

func (q sidecarQuery) ReloadAll(o *SidecarSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (sidecarQuery) SetApp

func (q sidecarQuery) SetApp(o *Sidecar, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetApp of the sidecar to the related item. Sets o.R.App to related. Adds o to related.R.Sidecars.

func (sidecarQuery) SidecarProcessTypes

func (q sidecarQuery) SidecarProcessTypes(o *Sidecar, mods ...qm.QueryMod) sidecarProcessTypeQuery

SidecarProcessTypes retrieves all the sidecar_process_type's SidecarProcessTypes with an executor.

func (sidecarQuery) Update

func (q sidecarQuery) Update(o *Sidecar, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Sidecar. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (sidecarQuery) UpdateAll

func (q sidecarQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (sidecarQuery) UpdateAllSlice

func (q sidecarQuery) UpdateAllSlice(o SidecarSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (sidecarQuery) Upsert

func (q sidecarQuery) Upsert(o *Sidecar, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type sidecarR

sidecarR is where relationships are stored.

type sidecarR struct {
    App                 *App                    `boil:"App" json:"App" toml:"App" yaml:"App"`
    SidecarProcessTypes SidecarProcessTypeSlice `boil:"SidecarProcessTypes" json:"SidecarProcessTypes" toml:"SidecarProcessTypes" yaml:"SidecarProcessTypes"`
}

func (*sidecarR) NewStruct

func (*sidecarR) NewStruct() *sidecarR

NewStruct creates a new relationship struct

type spaceAnnotationL

spaceAnnotationL is where Load methods for each relationship are stored.

type spaceAnnotationL struct{}

func (spaceAnnotationL) LoadResource

func (spaceAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpaceAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type spaceAnnotationQuery

type spaceAnnotationQuery struct {
    *queries.Query
}

func SpaceAnnotations

func SpaceAnnotations(mods ...qm.QueryMod) spaceAnnotationQuery

SpaceAnnotations retrieves all the records using an executor.

func (spaceAnnotationQuery) All

func (q spaceAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (SpaceAnnotationSlice, error)

All returns all SpaceAnnotation records from the query.

func (spaceAnnotationQuery) Count

func (q spaceAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all SpaceAnnotation records in the query.

func (spaceAnnotationQuery) Delete

func (q spaceAnnotationQuery) Delete(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single SpaceAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (spaceAnnotationQuery) DeleteAll

func (q spaceAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (spaceAnnotationQuery) DeleteAllSlice

func (q spaceAnnotationQuery) DeleteAllSlice(o SpaceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (spaceAnnotationQuery) Exists

func (q spaceAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (spaceAnnotationQuery) Insert

func (q spaceAnnotationQuery) Insert(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (spaceAnnotationQuery) One

func (q spaceAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*SpaceAnnotation, error)

One returns a single spaceAnnotation record from the query.

func (spaceAnnotationQuery) Reload

func (q spaceAnnotationQuery) Reload(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (spaceAnnotationQuery) ReloadAll

func (q spaceAnnotationQuery) ReloadAll(o *SpaceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (spaceAnnotationQuery) RemoveResource

func (q spaceAnnotationQuery) RemoveResource(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Space) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (spaceAnnotationQuery) Resource

func (q spaceAnnotationQuery) Resource(o *SpaceAnnotation, mods ...qm.QueryMod) spaceQuery

Resource pointed to by the foreign key.

func (spaceAnnotationQuery) SetResource

func (q spaceAnnotationQuery) SetResource(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetResource of the spaceAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceSpaceAnnotations.

func (spaceAnnotationQuery) Update

func (q spaceAnnotationQuery) Update(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the SpaceAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (spaceAnnotationQuery) UpdateAll

func (q spaceAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (spaceAnnotationQuery) UpdateAllSlice

func (q spaceAnnotationQuery) UpdateAllSlice(o SpaceAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (spaceAnnotationQuery) Upsert

func (q spaceAnnotationQuery) Upsert(o *SpaceAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type spaceAnnotationR

spaceAnnotationR is where relationships are stored.

type spaceAnnotationR struct {
    Resource *Space `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*spaceAnnotationR) NewStruct

func (*spaceAnnotationR) NewStruct() *spaceAnnotationR

NewStruct creates a new relationship struct

type spaceL

spaceL is where Load methods for each relationship are stored.

type spaceL struct{}

func (spaceL) LoadApps

func (spaceL) LoadApps(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadApps allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadDefaultSpaceUsers

func (spaceL) LoadDefaultSpaceUsers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadDefaultSpaceUsers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadIsolationSegment

func (spaceL) LoadIsolationSegment(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadIsolationSegment allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (spaceL) LoadOrganization

func (spaceL) LoadOrganization(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadOrganization allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (spaceL) LoadResourceSpaceAnnotations

func (spaceL) LoadResourceSpaceAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadResourceSpaceAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadResourceSpaceLabels

func (spaceL) LoadResourceSpaceLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadResourceSpaceLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadRoutes

func (spaceL) LoadRoutes(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadRoutes allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadSecurityGroupsSpaces

func (spaceL) LoadSecurityGroupsSpaces(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadSecurityGroupsSpaces allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadServiceBrokers

func (spaceL) LoadServiceBrokers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadServiceBrokers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadServiceInstances

func (spaceL) LoadServiceInstances(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadServiceInstances allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadSharedServiceInstances

func (spaceL) LoadSharedServiceInstances(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadSharedServiceInstances allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadSpaceQuotaDefinition

func (spaceL) LoadSpaceQuotaDefinition(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadSpaceQuotaDefinition allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (spaceL) LoadSpacesApplicationSupporters

func (spaceL) LoadSpacesApplicationSupporters(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadSpacesApplicationSupporters allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadSpacesAuditors

func (spaceL) LoadSpacesAuditors(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadSpacesAuditors allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadSpacesDevelopers

func (spaceL) LoadSpacesDevelopers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadSpacesDevelopers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadSpacesManagers

func (spaceL) LoadSpacesManagers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadSpacesManagers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (spaceL) LoadStagingSpaceStagingSecurityGroupsSpaces

func (spaceL) LoadStagingSpaceStagingSecurityGroupsSpaces(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpace interface{}, mods queries.Applicator) error

LoadStagingSpaceStagingSecurityGroupsSpaces allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type spaceLabelL

spaceLabelL is where Load methods for each relationship are stored.

type spaceLabelL struct{}

func (spaceLabelL) LoadResource

func (spaceLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpaceLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type spaceLabelQuery

type spaceLabelQuery struct {
    *queries.Query
}

func SpaceLabels

func SpaceLabels(mods ...qm.QueryMod) spaceLabelQuery

SpaceLabels retrieves all the records using an executor.

func (spaceLabelQuery) All

func (q spaceLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (SpaceLabelSlice, error)

All returns all SpaceLabel records from the query.

func (spaceLabelQuery) Count

func (q spaceLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all SpaceLabel records in the query.

func (spaceLabelQuery) Delete

func (q spaceLabelQuery) Delete(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single SpaceLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (spaceLabelQuery) DeleteAll

func (q spaceLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (spaceLabelQuery) DeleteAllSlice

func (q spaceLabelQuery) DeleteAllSlice(o SpaceLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (spaceLabelQuery) Exists

func (q spaceLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (spaceLabelQuery) Insert

func (q spaceLabelQuery) Insert(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (spaceLabelQuery) One

func (q spaceLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*SpaceLabel, error)

One returns a single spaceLabel record from the query.

func (spaceLabelQuery) Reload

func (q spaceLabelQuery) Reload(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (spaceLabelQuery) ReloadAll

func (q spaceLabelQuery) ReloadAll(o *SpaceLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (spaceLabelQuery) RemoveResource

func (q spaceLabelQuery) RemoveResource(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor, related *Space) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (spaceLabelQuery) Resource

func (q spaceLabelQuery) Resource(o *SpaceLabel, mods ...qm.QueryMod) spaceQuery

Resource pointed to by the foreign key.

func (spaceLabelQuery) SetResource

func (q spaceLabelQuery) SetResource(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetResource of the spaceLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceSpaceLabels.

func (spaceLabelQuery) Update

func (q spaceLabelQuery) Update(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the SpaceLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (spaceLabelQuery) UpdateAll

func (q spaceLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (spaceLabelQuery) UpdateAllSlice

func (q spaceLabelQuery) UpdateAllSlice(o SpaceLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (spaceLabelQuery) Upsert

func (q spaceLabelQuery) Upsert(o *SpaceLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type spaceLabelR

spaceLabelR is where relationships are stored.

type spaceLabelR struct {
    Resource *Space `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*spaceLabelR) NewStruct

func (*spaceLabelR) NewStruct() *spaceLabelR

NewStruct creates a new relationship struct

type spaceQuery

type spaceQuery struct {
    *queries.Query
}

func Spaces

func Spaces(mods ...qm.QueryMod) spaceQuery

Spaces retrieves all the records using an executor.

func (spaceQuery) AddApps

func (q spaceQuery) AddApps(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*App) error

AddApps adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.Apps. Sets related.R.Space appropriately.

func (spaceQuery) AddDefaultSpaceUsers

func (q spaceQuery) AddDefaultSpaceUsers(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*User) error

AddDefaultSpaceUsers adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.DefaultSpaceUsers. Sets related.R.DefaultSpace appropriately.

func (spaceQuery) AddResourceSpaceAnnotations

func (q spaceQuery) AddResourceSpaceAnnotations(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpaceAnnotation) error

AddResourceSpaceAnnotations adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.ResourceSpaceAnnotations. Sets related.R.Resource appropriately.

func (spaceQuery) AddResourceSpaceLabels

func (q spaceQuery) AddResourceSpaceLabels(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpaceLabel) error

AddResourceSpaceLabels adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.ResourceSpaceLabels. Sets related.R.Resource appropriately.

func (spaceQuery) AddRoutes

func (q spaceQuery) AddRoutes(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Route) error

AddRoutes adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.Routes. Sets related.R.Space appropriately.

func (spaceQuery) AddSecurityGroupsSpaces

func (q spaceQuery) AddSecurityGroupsSpaces(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SecurityGroupsSpace) error

AddSecurityGroupsSpaces adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.SecurityGroupsSpaces. Sets related.R.Space appropriately.

func (spaceQuery) AddServiceBrokers

func (q spaceQuery) AddServiceBrokers(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBroker) error

AddServiceBrokers adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.ServiceBrokers. Sets related.R.Space appropriately.

func (spaceQuery) AddServiceInstances

func (q spaceQuery) AddServiceInstances(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceInstance) error

AddServiceInstances adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.ServiceInstances. Sets related.R.Space appropriately.

func (spaceQuery) AddSharedServiceInstances

func (q spaceQuery) AddSharedServiceInstances(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceInstance) error

AddSharedServiceInstances adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.SharedServiceInstances. Sets related.R.Spaces appropriately.

func (spaceQuery) AddSpacesApplicationSupporters

func (q spaceQuery) AddSpacesApplicationSupporters(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpacesApplicationSupporter) error

AddSpacesApplicationSupporters adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.SpacesApplicationSupporters. Sets related.R.Space appropriately.

func (spaceQuery) AddSpacesAuditors

func (q spaceQuery) AddSpacesAuditors(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpacesAuditor) error

AddSpacesAuditors adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.SpacesAuditors. Sets related.R.Space appropriately.

func (spaceQuery) AddSpacesDevelopers

func (q spaceQuery) AddSpacesDevelopers(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpacesDeveloper) error

AddSpacesDevelopers adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.SpacesDevelopers. Sets related.R.Space appropriately.

func (spaceQuery) AddSpacesManagers

func (q spaceQuery) AddSpacesManagers(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpacesManager) error

AddSpacesManagers adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.SpacesManagers. Sets related.R.Space appropriately.

func (spaceQuery) AddStagingSpaceStagingSecurityGroupsSpaces

func (q spaceQuery) AddStagingSpaceStagingSecurityGroupsSpaces(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*StagingSecurityGroupsSpace) error

AddStagingSpaceStagingSecurityGroupsSpaces adds the given related objects to the existing relationships of the space\, optionally inserting them as new records. Appends related to o.R.StagingSpaceStagingSecurityGroupsSpaces. Sets related.R.StagingSpace appropriately.

func (spaceQuery) All

func (q spaceQuery) All(ctx context.Context, exec boil.ContextExecutor) (SpaceSlice, error)

All returns all Space records from the query.

func (spaceQuery) Apps

func (q spaceQuery) Apps(o *Space, mods ...qm.QueryMod) appQuery

Apps retrieves all the app's Apps with an executor.

func (spaceQuery) Count

func (q spaceQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Space records in the query.

func (spaceQuery) DefaultSpaceUsers

func (q spaceQuery) DefaultSpaceUsers(o *Space, mods ...qm.QueryMod) userQuery

DefaultSpaceUsers retrieves all the user's Users with an executor via default_space_id column.

func (spaceQuery) Delete

func (q spaceQuery) Delete(o *Space, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Space record with an executor. Delete will match against the primary key column to find the record to delete.

func (spaceQuery) DeleteAll

func (q spaceQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (spaceQuery) DeleteAllSlice

func (q spaceQuery) DeleteAllSlice(o SpaceSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (spaceQuery) Exists

func (q spaceQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (spaceQuery) Insert

func (q spaceQuery) Insert(o *Space, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (spaceQuery) IsolationSegment

func (q spaceQuery) IsolationSegment(o *Space, mods ...qm.QueryMod) isolationSegmentQuery

IsolationSegment pointed to by the foreign key.

func (spaceQuery) One

func (q spaceQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Space, error)

One returns a single space record from the query.

func (spaceQuery) Organization

func (q spaceQuery) Organization(o *Space, mods ...qm.QueryMod) organizationQuery

Organization pointed to by the foreign key.

func (spaceQuery) Reload

func (q spaceQuery) Reload(o *Space, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (spaceQuery) ReloadAll

func (q spaceQuery) ReloadAll(o *SpaceSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (spaceQuery) RemoveApps

func (q spaceQuery) RemoveApps(o *Space, ctx context.Context, exec boil.ContextExecutor, related ...*App) error

RemoveApps relationships from objects passed in. Removes related items from R.Apps (uses pointer comparison\, removal does not keep order) Sets related.R.Space.

func (spaceQuery) RemoveDefaultSpaceUsers

func (q spaceQuery) RemoveDefaultSpaceUsers(o *Space, ctx context.Context, exec boil.ContextExecutor, related ...*User) error

RemoveDefaultSpaceUsers relationships from objects passed in. Removes related items from R.DefaultSpaceUsers (uses pointer comparison\, removal does not keep order) Sets related.R.DefaultSpace.

func (spaceQuery) RemoveIsolationSegment

func (q spaceQuery) RemoveIsolationSegment(o *Space, ctx context.Context, exec boil.ContextExecutor, related *IsolationSegment) error

RemoveIsolationSegment relationship. Sets o.R.IsolationSegment to nil. Removes o from all passed in related items' relationships struct (Optional).

func (spaceQuery) RemoveResourceSpaceAnnotations

func (q spaceQuery) RemoveResourceSpaceAnnotations(o *Space, ctx context.Context, exec boil.ContextExecutor, related ...*SpaceAnnotation) error

RemoveResourceSpaceAnnotations relationships from objects passed in. Removes related items from R.ResourceSpaceAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (spaceQuery) RemoveResourceSpaceLabels

func (q spaceQuery) RemoveResourceSpaceLabels(o *Space, ctx context.Context, exec boil.ContextExecutor, related ...*SpaceLabel) error

RemoveResourceSpaceLabels relationships from objects passed in. Removes related items from R.ResourceSpaceLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (spaceQuery) RemoveServiceBrokers

func (q spaceQuery) RemoveServiceBrokers(o *Space, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceBroker) error

RemoveServiceBrokers relationships from objects passed in. Removes related items from R.ServiceBrokers (uses pointer comparison\, removal does not keep order) Sets related.R.Space.

func (spaceQuery) RemoveSharedServiceInstances

func (q spaceQuery) RemoveSharedServiceInstances(o *Space, ctx context.Context, exec boil.ContextExecutor, related ...*ServiceInstance) error

RemoveSharedServiceInstances relationships from objects passed in. Removes related items from R.SharedServiceInstances (uses pointer comparison\, removal does not keep order) Sets related.R.Spaces.

func (spaceQuery) RemoveSpaceQuotaDefinition

func (q spaceQuery) RemoveSpaceQuotaDefinition(o *Space, ctx context.Context, exec boil.ContextExecutor, related *SpaceQuotaDefinition) error

RemoveSpaceQuotaDefinition relationship. Sets o.R.SpaceQuotaDefinition to nil. Removes o from all passed in related items' relationships struct (Optional).

func (spaceQuery) ResourceSpaceAnnotations

func (q spaceQuery) ResourceSpaceAnnotations(o *Space, mods ...qm.QueryMod) spaceAnnotationQuery

ResourceSpaceAnnotations retrieves all the space_annotation's SpaceAnnotations with an executor via resource_guid column.

func (spaceQuery) ResourceSpaceLabels

func (q spaceQuery) ResourceSpaceLabels(o *Space, mods ...qm.QueryMod) spaceLabelQuery

ResourceSpaceLabels retrieves all the space_label's SpaceLabels with an executor via resource_guid column.

func (spaceQuery) Routes

func (q spaceQuery) Routes(o *Space, mods ...qm.QueryMod) routeQuery

Routes retrieves all the route's Routes with an executor.

func (spaceQuery) SecurityGroupsSpaces

func (q spaceQuery) SecurityGroupsSpaces(o *Space, mods ...qm.QueryMod) securityGroupsSpaceQuery

SecurityGroupsSpaces retrieves all the security_groups_space's SecurityGroupsSpaces with an executor.

func (spaceQuery) ServiceBrokers

func (q spaceQuery) ServiceBrokers(o *Space, mods ...qm.QueryMod) serviceBrokerQuery

ServiceBrokers retrieves all the service_broker's ServiceBrokers with an executor.

func (spaceQuery) ServiceInstances

func (q spaceQuery) ServiceInstances(o *Space, mods ...qm.QueryMod) serviceInstanceQuery

ServiceInstances retrieves all the service_instance's ServiceInstances with an executor.

func (spaceQuery) SetApps

func (q spaceQuery) SetApps(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*App) error

SetApps removes all previously related items of the space replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Space's Apps accordingly. Replaces o.R.Apps with related. Sets related.R.Space's Apps accordingly.

func (spaceQuery) SetDefaultSpaceUsers

func (q spaceQuery) SetDefaultSpaceUsers(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*User) error

SetDefaultSpaceUsers removes all previously related items of the space replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.DefaultSpace's DefaultSpaceUsers accordingly. Replaces o.R.DefaultSpaceUsers with related. Sets related.R.DefaultSpace's DefaultSpaceUsers accordingly.

func (spaceQuery) SetIsolationSegment

func (q spaceQuery) SetIsolationSegment(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related *IsolationSegment) error

SetIsolationSegment of the space to the related item. Sets o.R.IsolationSegment to related. Adds o to related.R.Spaces.

func (spaceQuery) SetOrganization

func (q spaceQuery) SetOrganization(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Organization) error

SetOrganization of the space to the related item. Sets o.R.Organization to related. Adds o to related.R.Spaces.

func (spaceQuery) SetResourceSpaceAnnotations

func (q spaceQuery) SetResourceSpaceAnnotations(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpaceAnnotation) error

SetResourceSpaceAnnotations removes all previously related items of the space replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceSpaceAnnotations accordingly. Replaces o.R.ResourceSpaceAnnotations with related. Sets related.R.Resource's ResourceSpaceAnnotations accordingly.

func (spaceQuery) SetResourceSpaceLabels

func (q spaceQuery) SetResourceSpaceLabels(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpaceLabel) error

SetResourceSpaceLabels removes all previously related items of the space replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceSpaceLabels accordingly. Replaces o.R.ResourceSpaceLabels with related. Sets related.R.Resource's ResourceSpaceLabels accordingly.

func (spaceQuery) SetServiceBrokers

func (q spaceQuery) SetServiceBrokers(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceBroker) error

SetServiceBrokers removes all previously related items of the space replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Space's ServiceBrokers accordingly. Replaces o.R.ServiceBrokers with related. Sets related.R.Space's ServiceBrokers accordingly.

func (spaceQuery) SetSharedServiceInstances

func (q spaceQuery) SetSharedServiceInstances(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServiceInstance) error

SetSharedServiceInstances removes all previously related items of the space replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Spaces's SharedServiceInstances accordingly. Replaces o.R.SharedServiceInstances with related. Sets related.R.Spaces's SharedServiceInstances accordingly.

func (spaceQuery) SetSpaceQuotaDefinition

func (q spaceQuery) SetSpaceQuotaDefinition(o *Space, ctx context.Context, exec boil.ContextExecutor, insert bool, related *SpaceQuotaDefinition) error

SetSpaceQuotaDefinition of the space to the related item. Sets o.R.SpaceQuotaDefinition to related. Adds o to related.R.Spaces.

func (spaceQuery) SharedServiceInstances

func (q spaceQuery) SharedServiceInstances(o *Space, mods ...qm.QueryMod) serviceInstanceQuery

SharedServiceInstances retrieves all the service_instance's ServiceInstances with an executor via guid column.

func (spaceQuery) SpaceQuotaDefinition

func (q spaceQuery) SpaceQuotaDefinition(o *Space, mods ...qm.QueryMod) spaceQuotaDefinitionQuery

SpaceQuotaDefinition pointed to by the foreign key.

func (spaceQuery) SpacesApplicationSupporters

func (q spaceQuery) SpacesApplicationSupporters(o *Space, mods ...qm.QueryMod) spacesApplicationSupporterQuery

SpacesApplicationSupporters retrieves all the spaces_application_supporter's SpacesApplicationSupporters with an executor.

func (spaceQuery) SpacesAuditors

func (q spaceQuery) SpacesAuditors(o *Space, mods ...qm.QueryMod) spacesAuditorQuery

SpacesAuditors retrieves all the spaces_auditor's SpacesAuditors with an executor.

func (spaceQuery) SpacesDevelopers

func (q spaceQuery) SpacesDevelopers(o *Space, mods ...qm.QueryMod) spacesDeveloperQuery

SpacesDevelopers retrieves all the spaces_developer's SpacesDevelopers with an executor.

func (spaceQuery) SpacesManagers

func (q spaceQuery) SpacesManagers(o *Space, mods ...qm.QueryMod) spacesManagerQuery

SpacesManagers retrieves all the spaces_manager's SpacesManagers with an executor.

func (spaceQuery) StagingSpaceStagingSecurityGroupsSpaces

func (q spaceQuery) StagingSpaceStagingSecurityGroupsSpaces(o *Space, mods ...qm.QueryMod) stagingSecurityGroupsSpaceQuery

StagingSpaceStagingSecurityGroupsSpaces retrieves all the staging_security_groups_space's StagingSecurityGroupsSpaces with an executor via staging_space_id column.

func (spaceQuery) Update

func (q spaceQuery) Update(o *Space, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Space. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (spaceQuery) UpdateAll

func (q spaceQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (spaceQuery) UpdateAllSlice

func (q spaceQuery) UpdateAllSlice(o SpaceSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (spaceQuery) Upsert

func (q spaceQuery) Upsert(o *Space, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type spaceQuotaDefinitionL

spaceQuotaDefinitionL is where Load methods for each relationship are stored.

type spaceQuotaDefinitionL struct{}

func (spaceQuotaDefinitionL) LoadOrganization

func (spaceQuotaDefinitionL) LoadOrganization(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpaceQuotaDefinition interface{}, mods queries.Applicator) error

LoadOrganization allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (spaceQuotaDefinitionL) LoadSpaces

func (spaceQuotaDefinitionL) LoadSpaces(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpaceQuotaDefinition interface{}, mods queries.Applicator) error

LoadSpaces allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type spaceQuotaDefinitionQuery

type spaceQuotaDefinitionQuery struct {
    *queries.Query
}

func SpaceQuotaDefinitions

func SpaceQuotaDefinitions(mods ...qm.QueryMod) spaceQuotaDefinitionQuery

SpaceQuotaDefinitions retrieves all the records using an executor.

func (spaceQuotaDefinitionQuery) AddSpaces

func (q spaceQuotaDefinitionQuery) AddSpaces(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Space) error

AddSpaces adds the given related objects to the existing relationships of the space_quota_definition\, optionally inserting them as new records. Appends related to o.R.Spaces. Sets related.R.SpaceQuotaDefinition appropriately.

func (spaceQuotaDefinitionQuery) All

func (q spaceQuotaDefinitionQuery) All(ctx context.Context, exec boil.ContextExecutor) (SpaceQuotaDefinitionSlice, error)

All returns all SpaceQuotaDefinition records from the query.

func (spaceQuotaDefinitionQuery) Count

func (q spaceQuotaDefinitionQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all SpaceQuotaDefinition records in the query.

func (spaceQuotaDefinitionQuery) Delete

func (q spaceQuotaDefinitionQuery) Delete(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single SpaceQuotaDefinition record with an executor. Delete will match against the primary key column to find the record to delete.

func (spaceQuotaDefinitionQuery) DeleteAll

func (q spaceQuotaDefinitionQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (spaceQuotaDefinitionQuery) DeleteAllSlice

func (q spaceQuotaDefinitionQuery) DeleteAllSlice(o SpaceQuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (spaceQuotaDefinitionQuery) Exists

func (q spaceQuotaDefinitionQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (spaceQuotaDefinitionQuery) Insert

func (q spaceQuotaDefinitionQuery) Insert(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (spaceQuotaDefinitionQuery) One

func (q spaceQuotaDefinitionQuery) One(ctx context.Context, exec boil.ContextExecutor) (*SpaceQuotaDefinition, error)

One returns a single spaceQuotaDefinition record from the query.

func (spaceQuotaDefinitionQuery) Organization

func (q spaceQuotaDefinitionQuery) Organization(o *SpaceQuotaDefinition, mods ...qm.QueryMod) organizationQuery

Organization pointed to by the foreign key.

func (spaceQuotaDefinitionQuery) Reload

func (q spaceQuotaDefinitionQuery) Reload(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (spaceQuotaDefinitionQuery) ReloadAll

func (q spaceQuotaDefinitionQuery) ReloadAll(o *SpaceQuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (spaceQuotaDefinitionQuery) RemoveSpaces

func (q spaceQuotaDefinitionQuery) RemoveSpaces(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor, related ...*Space) error

RemoveSpaces relationships from objects passed in. Removes related items from R.Spaces (uses pointer comparison\, removal does not keep order) Sets related.R.SpaceQuotaDefinition.

func (spaceQuotaDefinitionQuery) SetOrganization

func (q spaceQuotaDefinitionQuery) SetOrganization(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Organization) error

SetOrganization of the spaceQuotaDefinition to the related item. Sets o.R.Organization to related. Adds o to related.R.SpaceQuotaDefinitions.

func (spaceQuotaDefinitionQuery) SetSpaces

func (q spaceQuotaDefinitionQuery) SetSpaces(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Space) error

SetSpaces removes all previously related items of the space_quota_definition replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.SpaceQuotaDefinition's Spaces accordingly. Replaces o.R.Spaces with related. Sets related.R.SpaceQuotaDefinition's Spaces accordingly.

func (spaceQuotaDefinitionQuery) Spaces

func (q spaceQuotaDefinitionQuery) Spaces(o *SpaceQuotaDefinition, mods ...qm.QueryMod) spaceQuery

Spaces retrieves all the space's Spaces with an executor.

func (spaceQuotaDefinitionQuery) Update

func (q spaceQuotaDefinitionQuery) Update(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the SpaceQuotaDefinition. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (spaceQuotaDefinitionQuery) UpdateAll

func (q spaceQuotaDefinitionQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (spaceQuotaDefinitionQuery) UpdateAllSlice

func (q spaceQuotaDefinitionQuery) UpdateAllSlice(o SpaceQuotaDefinitionSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (spaceQuotaDefinitionQuery) Upsert

func (q spaceQuotaDefinitionQuery) Upsert(o *SpaceQuotaDefinition, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type spaceQuotaDefinitionR

spaceQuotaDefinitionR is where relationships are stored.

type spaceQuotaDefinitionR struct {
    Organization *Organization `boil:"Organization" json:"Organization" toml:"Organization" yaml:"Organization"`
    Spaces       SpaceSlice    `boil:"Spaces" json:"Spaces" toml:"Spaces" yaml:"Spaces"`
}

func (*spaceQuotaDefinitionR) NewStruct

func (*spaceQuotaDefinitionR) NewStruct() *spaceQuotaDefinitionR

NewStruct creates a new relationship struct

type spaceR

spaceR is where relationships are stored.

type spaceR struct {
    SpaceQuotaDefinition                    *SpaceQuotaDefinition           `boil:"SpaceQuotaDefinition" json:"SpaceQuotaDefinition" toml:"SpaceQuotaDefinition" yaml:"SpaceQuotaDefinition"`
    IsolationSegment                        *IsolationSegment               `boil:"IsolationSegment" json:"IsolationSegment" toml:"IsolationSegment" yaml:"IsolationSegment"`
    Organization                            *Organization                   `boil:"Organization" json:"Organization" toml:"Organization" yaml:"Organization"`
    Apps                                    AppSlice                        `boil:"Apps" json:"Apps" toml:"Apps" yaml:"Apps"`
    Routes                                  RouteSlice                      `boil:"Routes" json:"Routes" toml:"Routes" yaml:"Routes"`
    SecurityGroupsSpaces                    SecurityGroupsSpaceSlice        `boil:"SecurityGroupsSpaces" json:"SecurityGroupsSpaces" toml:"SecurityGroupsSpaces" yaml:"SecurityGroupsSpaces"`
    ServiceBrokers                          ServiceBrokerSlice              `boil:"ServiceBrokers" json:"ServiceBrokers" toml:"ServiceBrokers" yaml:"ServiceBrokers"`
    SharedServiceInstances                  ServiceInstanceSlice            `boil:"SharedServiceInstances" json:"SharedServiceInstances" toml:"SharedServiceInstances" yaml:"SharedServiceInstances"`
    ServiceInstances                        ServiceInstanceSlice            `boil:"ServiceInstances" json:"ServiceInstances" toml:"ServiceInstances" yaml:"ServiceInstances"`
    ResourceSpaceAnnotations                SpaceAnnotationSlice            `boil:"ResourceSpaceAnnotations" json:"ResourceSpaceAnnotations" toml:"ResourceSpaceAnnotations" yaml:"ResourceSpaceAnnotations"`
    ResourceSpaceLabels                     SpaceLabelSlice                 `boil:"ResourceSpaceLabels" json:"ResourceSpaceLabels" toml:"ResourceSpaceLabels" yaml:"ResourceSpaceLabels"`
    SpacesApplicationSupporters             SpacesApplicationSupporterSlice `boil:"SpacesApplicationSupporters" json:"SpacesApplicationSupporters" toml:"SpacesApplicationSupporters" yaml:"SpacesApplicationSupporters"`
    SpacesAuditors                          SpacesAuditorSlice              `boil:"SpacesAuditors" json:"SpacesAuditors" toml:"SpacesAuditors" yaml:"SpacesAuditors"`
    SpacesDevelopers                        SpacesDeveloperSlice            `boil:"SpacesDevelopers" json:"SpacesDevelopers" toml:"SpacesDevelopers" yaml:"SpacesDevelopers"`
    SpacesManagers                          SpacesManagerSlice              `boil:"SpacesManagers" json:"SpacesManagers" toml:"SpacesManagers" yaml:"SpacesManagers"`
    StagingSpaceStagingSecurityGroupsSpaces StagingSecurityGroupsSpaceSlice `boil:"StagingSpaceStagingSecurityGroupsSpaces" json:"StagingSpaceStagingSecurityGroupsSpaces" toml:"StagingSpaceStagingSecurityGroupsSpaces" yaml:"StagingSpaceStagingSecurityGroupsSpaces"`
    DefaultSpaceUsers                       UserSlice                       `boil:"DefaultSpaceUsers" json:"DefaultSpaceUsers" toml:"DefaultSpaceUsers" yaml:"DefaultSpaceUsers"`
}

func (*spaceR) NewStruct

func (*spaceR) NewStruct() *spaceR

NewStruct creates a new relationship struct

type spacesApplicationSupporterL

spacesApplicationSupporterL is where Load methods for each relationship are stored.

type spacesApplicationSupporterL struct{}

func (spacesApplicationSupporterL) LoadSpace

func (spacesApplicationSupporterL) LoadSpace(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpacesApplicationSupporter interface{}, mods queries.Applicator) error

LoadSpace allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (spacesApplicationSupporterL) LoadUser

func (spacesApplicationSupporterL) LoadUser(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpacesApplicationSupporter interface{}, mods queries.Applicator) error

LoadUser allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type spacesApplicationSupporterQuery

type spacesApplicationSupporterQuery struct {
    *queries.Query
}

func SpacesApplicationSupporters

func SpacesApplicationSupporters(mods ...qm.QueryMod) spacesApplicationSupporterQuery

SpacesApplicationSupporters retrieves all the records using an executor.

func (spacesApplicationSupporterQuery) All

func (q spacesApplicationSupporterQuery) All(ctx context.Context, exec boil.ContextExecutor) (SpacesApplicationSupporterSlice, error)

All returns all SpacesApplicationSupporter records from the query.

func (spacesApplicationSupporterQuery) Count

func (q spacesApplicationSupporterQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all SpacesApplicationSupporter records in the query.

func (spacesApplicationSupporterQuery) Delete

func (q spacesApplicationSupporterQuery) Delete(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single SpacesApplicationSupporter record with an executor. Delete will match against the primary key column to find the record to delete.

func (spacesApplicationSupporterQuery) DeleteAll

func (q spacesApplicationSupporterQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (spacesApplicationSupporterQuery) DeleteAllSlice

func (q spacesApplicationSupporterQuery) DeleteAllSlice(o SpacesApplicationSupporterSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (spacesApplicationSupporterQuery) Exists

func (q spacesApplicationSupporterQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (spacesApplicationSupporterQuery) Insert

func (q spacesApplicationSupporterQuery) Insert(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (spacesApplicationSupporterQuery) One

func (q spacesApplicationSupporterQuery) One(ctx context.Context, exec boil.ContextExecutor) (*SpacesApplicationSupporter, error)

One returns a single spacesApplicationSupporter record from the query.

func (spacesApplicationSupporterQuery) Reload

func (q spacesApplicationSupporterQuery) Reload(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (spacesApplicationSupporterQuery) ReloadAll

func (q spacesApplicationSupporterQuery) ReloadAll(o *SpacesApplicationSupporterSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (spacesApplicationSupporterQuery) SetSpace

func (q spacesApplicationSupporterQuery) SetSpace(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetSpace of the spacesApplicationSupporter to the related item. Sets o.R.Space to related. Adds o to related.R.SpacesApplicationSupporters.

func (spacesApplicationSupporterQuery) SetUser

func (q spacesApplicationSupporterQuery) SetUser(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor, insert bool, related *User) error

SetUser of the spacesApplicationSupporter to the related item. Sets o.R.User to related. Adds o to related.R.SpacesApplicationSupporters.

func (spacesApplicationSupporterQuery) Space

func (q spacesApplicationSupporterQuery) Space(o *SpacesApplicationSupporter, mods ...qm.QueryMod) spaceQuery

Space pointed to by the foreign key.

func (spacesApplicationSupporterQuery) Update

func (q spacesApplicationSupporterQuery) Update(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the SpacesApplicationSupporter. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (spacesApplicationSupporterQuery) UpdateAll

func (q spacesApplicationSupporterQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (spacesApplicationSupporterQuery) UpdateAllSlice

func (q spacesApplicationSupporterQuery) UpdateAllSlice(o SpacesApplicationSupporterSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (spacesApplicationSupporterQuery) Upsert

func (q spacesApplicationSupporterQuery) Upsert(o *SpacesApplicationSupporter, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

func (spacesApplicationSupporterQuery) User

func (q spacesApplicationSupporterQuery) User(o *SpacesApplicationSupporter, mods ...qm.QueryMod) userQuery

User pointed to by the foreign key.

type spacesApplicationSupporterR

spacesApplicationSupporterR is where relationships are stored.

type spacesApplicationSupporterR struct {
    Space *Space `boil:"Space" json:"Space" toml:"Space" yaml:"Space"`
    User  *User  `boil:"User" json:"User" toml:"User" yaml:"User"`
}

func (*spacesApplicationSupporterR) NewStruct

func (*spacesApplicationSupporterR) NewStruct() *spacesApplicationSupporterR

NewStruct creates a new relationship struct

type spacesAuditorL

spacesAuditorL is where Load methods for each relationship are stored.

type spacesAuditorL struct{}

func (spacesAuditorL) LoadSpace

func (spacesAuditorL) LoadSpace(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpacesAuditor interface{}, mods queries.Applicator) error

LoadSpace allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (spacesAuditorL) LoadUser

func (spacesAuditorL) LoadUser(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpacesAuditor interface{}, mods queries.Applicator) error

LoadUser allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type spacesAuditorQuery

type spacesAuditorQuery struct {
    *queries.Query
}

func SpacesAuditors

func SpacesAuditors(mods ...qm.QueryMod) spacesAuditorQuery

SpacesAuditors retrieves all the records using an executor.

func (spacesAuditorQuery) All

func (q spacesAuditorQuery) All(ctx context.Context, exec boil.ContextExecutor) (SpacesAuditorSlice, error)

All returns all SpacesAuditor records from the query.

func (spacesAuditorQuery) Count

func (q spacesAuditorQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all SpacesAuditor records in the query.

func (spacesAuditorQuery) Delete

func (q spacesAuditorQuery) Delete(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single SpacesAuditor record with an executor. Delete will match against the primary key column to find the record to delete.

func (spacesAuditorQuery) DeleteAll

func (q spacesAuditorQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (spacesAuditorQuery) DeleteAllSlice

func (q spacesAuditorQuery) DeleteAllSlice(o SpacesAuditorSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (spacesAuditorQuery) Exists

func (q spacesAuditorQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (spacesAuditorQuery) Insert

func (q spacesAuditorQuery) Insert(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (spacesAuditorQuery) One

func (q spacesAuditorQuery) One(ctx context.Context, exec boil.ContextExecutor) (*SpacesAuditor, error)

One returns a single spacesAuditor record from the query.

func (spacesAuditorQuery) Reload

func (q spacesAuditorQuery) Reload(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (spacesAuditorQuery) ReloadAll

func (q spacesAuditorQuery) ReloadAll(o *SpacesAuditorSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (spacesAuditorQuery) SetSpace

func (q spacesAuditorQuery) SetSpace(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetSpace of the spacesAuditor to the related item. Sets o.R.Space to related. Adds o to related.R.SpacesAuditors.

func (spacesAuditorQuery) SetUser

func (q spacesAuditorQuery) SetUser(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor, insert bool, related *User) error

SetUser of the spacesAuditor to the related item. Sets o.R.User to related. Adds o to related.R.SpacesAuditors.

func (spacesAuditorQuery) Space

func (q spacesAuditorQuery) Space(o *SpacesAuditor, mods ...qm.QueryMod) spaceQuery

Space pointed to by the foreign key.

func (spacesAuditorQuery) Update

func (q spacesAuditorQuery) Update(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the SpacesAuditor. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (spacesAuditorQuery) UpdateAll

func (q spacesAuditorQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (spacesAuditorQuery) UpdateAllSlice

func (q spacesAuditorQuery) UpdateAllSlice(o SpacesAuditorSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (spacesAuditorQuery) Upsert

func (q spacesAuditorQuery) Upsert(o *SpacesAuditor, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

func (spacesAuditorQuery) User

func (q spacesAuditorQuery) User(o *SpacesAuditor, mods ...qm.QueryMod) userQuery

User pointed to by the foreign key.

type spacesAuditorR

spacesAuditorR is where relationships are stored.

type spacesAuditorR struct {
    Space *Space `boil:"Space" json:"Space" toml:"Space" yaml:"Space"`
    User  *User  `boil:"User" json:"User" toml:"User" yaml:"User"`
}

func (*spacesAuditorR) NewStruct

func (*spacesAuditorR) NewStruct() *spacesAuditorR

NewStruct creates a new relationship struct

type spacesDeveloperL

spacesDeveloperL is where Load methods for each relationship are stored.

type spacesDeveloperL struct{}

func (spacesDeveloperL) LoadSpace

func (spacesDeveloperL) LoadSpace(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpacesDeveloper interface{}, mods queries.Applicator) error

LoadSpace allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (spacesDeveloperL) LoadUser

func (spacesDeveloperL) LoadUser(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpacesDeveloper interface{}, mods queries.Applicator) error

LoadUser allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type spacesDeveloperQuery

type spacesDeveloperQuery struct {
    *queries.Query
}

func SpacesDevelopers

func SpacesDevelopers(mods ...qm.QueryMod) spacesDeveloperQuery

SpacesDevelopers retrieves all the records using an executor.

func (spacesDeveloperQuery) All

func (q spacesDeveloperQuery) All(ctx context.Context, exec boil.ContextExecutor) (SpacesDeveloperSlice, error)

All returns all SpacesDeveloper records from the query.

func (spacesDeveloperQuery) Count

func (q spacesDeveloperQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all SpacesDeveloper records in the query.

func (spacesDeveloperQuery) Delete

func (q spacesDeveloperQuery) Delete(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single SpacesDeveloper record with an executor. Delete will match against the primary key column to find the record to delete.

func (spacesDeveloperQuery) DeleteAll

func (q spacesDeveloperQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (spacesDeveloperQuery) DeleteAllSlice

func (q spacesDeveloperQuery) DeleteAllSlice(o SpacesDeveloperSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (spacesDeveloperQuery) Exists

func (q spacesDeveloperQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (spacesDeveloperQuery) Insert

func (q spacesDeveloperQuery) Insert(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (spacesDeveloperQuery) One

func (q spacesDeveloperQuery) One(ctx context.Context, exec boil.ContextExecutor) (*SpacesDeveloper, error)

One returns a single spacesDeveloper record from the query.

func (spacesDeveloperQuery) Reload

func (q spacesDeveloperQuery) Reload(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (spacesDeveloperQuery) ReloadAll

func (q spacesDeveloperQuery) ReloadAll(o *SpacesDeveloperSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (spacesDeveloperQuery) SetSpace

func (q spacesDeveloperQuery) SetSpace(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetSpace of the spacesDeveloper to the related item. Sets o.R.Space to related. Adds o to related.R.SpacesDevelopers.

func (spacesDeveloperQuery) SetUser

func (q spacesDeveloperQuery) SetUser(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor, insert bool, related *User) error

SetUser of the spacesDeveloper to the related item. Sets o.R.User to related. Adds o to related.R.SpacesDevelopers.

func (spacesDeveloperQuery) Space

func (q spacesDeveloperQuery) Space(o *SpacesDeveloper, mods ...qm.QueryMod) spaceQuery

Space pointed to by the foreign key.

func (spacesDeveloperQuery) Update

func (q spacesDeveloperQuery) Update(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the SpacesDeveloper. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (spacesDeveloperQuery) UpdateAll

func (q spacesDeveloperQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (spacesDeveloperQuery) UpdateAllSlice

func (q spacesDeveloperQuery) UpdateAllSlice(o SpacesDeveloperSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (spacesDeveloperQuery) Upsert

func (q spacesDeveloperQuery) Upsert(o *SpacesDeveloper, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

func (spacesDeveloperQuery) User

func (q spacesDeveloperQuery) User(o *SpacesDeveloper, mods ...qm.QueryMod) userQuery

User pointed to by the foreign key.

type spacesDeveloperR

spacesDeveloperR is where relationships are stored.

type spacesDeveloperR struct {
    Space *Space `boil:"Space" json:"Space" toml:"Space" yaml:"Space"`
    User  *User  `boil:"User" json:"User" toml:"User" yaml:"User"`
}

func (*spacesDeveloperR) NewStruct

func (*spacesDeveloperR) NewStruct() *spacesDeveloperR

NewStruct creates a new relationship struct

type spacesManagerL

spacesManagerL is where Load methods for each relationship are stored.

type spacesManagerL struct{}

func (spacesManagerL) LoadSpace

func (spacesManagerL) LoadSpace(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpacesManager interface{}, mods queries.Applicator) error

LoadSpace allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (spacesManagerL) LoadUser

func (spacesManagerL) LoadUser(ctx context.Context, e boil.ContextExecutor, singular bool, maybeSpacesManager interface{}, mods queries.Applicator) error

LoadUser allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type spacesManagerQuery

type spacesManagerQuery struct {
    *queries.Query
}

func SpacesManagers

func SpacesManagers(mods ...qm.QueryMod) spacesManagerQuery

SpacesManagers retrieves all the records using an executor.

func (spacesManagerQuery) All

func (q spacesManagerQuery) All(ctx context.Context, exec boil.ContextExecutor) (SpacesManagerSlice, error)

All returns all SpacesManager records from the query.

func (spacesManagerQuery) Count

func (q spacesManagerQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all SpacesManager records in the query.

func (spacesManagerQuery) Delete

func (q spacesManagerQuery) Delete(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single SpacesManager record with an executor. Delete will match against the primary key column to find the record to delete.

func (spacesManagerQuery) DeleteAll

func (q spacesManagerQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (spacesManagerQuery) DeleteAllSlice

func (q spacesManagerQuery) DeleteAllSlice(o SpacesManagerSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (spacesManagerQuery) Exists

func (q spacesManagerQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (spacesManagerQuery) Insert

func (q spacesManagerQuery) Insert(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (spacesManagerQuery) One

func (q spacesManagerQuery) One(ctx context.Context, exec boil.ContextExecutor) (*SpacesManager, error)

One returns a single spacesManager record from the query.

func (spacesManagerQuery) Reload

func (q spacesManagerQuery) Reload(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (spacesManagerQuery) ReloadAll

func (q spacesManagerQuery) ReloadAll(o *SpacesManagerSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (spacesManagerQuery) SetSpace

func (q spacesManagerQuery) SetSpace(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetSpace of the spacesManager to the related item. Sets o.R.Space to related. Adds o to related.R.SpacesManagers.

func (spacesManagerQuery) SetUser

func (q spacesManagerQuery) SetUser(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor, insert bool, related *User) error

SetUser of the spacesManager to the related item. Sets o.R.User to related. Adds o to related.R.SpacesManagers.

func (spacesManagerQuery) Space

func (q spacesManagerQuery) Space(o *SpacesManager, mods ...qm.QueryMod) spaceQuery

Space pointed to by the foreign key.

func (spacesManagerQuery) Update

func (q spacesManagerQuery) Update(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the SpacesManager. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (spacesManagerQuery) UpdateAll

func (q spacesManagerQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (spacesManagerQuery) UpdateAllSlice

func (q spacesManagerQuery) UpdateAllSlice(o SpacesManagerSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (spacesManagerQuery) Upsert

func (q spacesManagerQuery) Upsert(o *SpacesManager, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

func (spacesManagerQuery) User

func (q spacesManagerQuery) User(o *SpacesManager, mods ...qm.QueryMod) userQuery

User pointed to by the foreign key.

type spacesManagerR

spacesManagerR is where relationships are stored.

type spacesManagerR struct {
    Space *Space `boil:"Space" json:"Space" toml:"Space" yaml:"Space"`
    User  *User  `boil:"User" json:"User" toml:"User" yaml:"User"`
}

func (*spacesManagerR) NewStruct

func (*spacesManagerR) NewStruct() *spacesManagerR

NewStruct creates a new relationship struct

type stackAnnotationL

stackAnnotationL is where Load methods for each relationship are stored.

type stackAnnotationL struct{}

func (stackAnnotationL) LoadResource

func (stackAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeStackAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type stackAnnotationQuery

type stackAnnotationQuery struct {
    *queries.Query
}

func StackAnnotations

func StackAnnotations(mods ...qm.QueryMod) stackAnnotationQuery

StackAnnotations retrieves all the records using an executor.

func (stackAnnotationQuery) All

func (q stackAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (StackAnnotationSlice, error)

All returns all StackAnnotation records from the query.

func (stackAnnotationQuery) Count

func (q stackAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all StackAnnotation records in the query.

func (stackAnnotationQuery) Delete

func (q stackAnnotationQuery) Delete(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single StackAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (stackAnnotationQuery) DeleteAll

func (q stackAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (stackAnnotationQuery) DeleteAllSlice

func (q stackAnnotationQuery) DeleteAllSlice(o StackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (stackAnnotationQuery) Exists

func (q stackAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (stackAnnotationQuery) Insert

func (q stackAnnotationQuery) Insert(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (stackAnnotationQuery) One

func (q stackAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*StackAnnotation, error)

One returns a single stackAnnotation record from the query.

func (stackAnnotationQuery) Reload

func (q stackAnnotationQuery) Reload(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (stackAnnotationQuery) ReloadAll

func (q stackAnnotationQuery) ReloadAll(o *StackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (stackAnnotationQuery) RemoveResource

func (q stackAnnotationQuery) RemoveResource(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Stack) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (stackAnnotationQuery) Resource

func (q stackAnnotationQuery) Resource(o *StackAnnotation, mods ...qm.QueryMod) stackQuery

Resource pointed to by the foreign key.

func (stackAnnotationQuery) SetResource

func (q stackAnnotationQuery) SetResource(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Stack) error

SetResource of the stackAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceStackAnnotations.

func (stackAnnotationQuery) Update

func (q stackAnnotationQuery) Update(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the StackAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (stackAnnotationQuery) UpdateAll

func (q stackAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (stackAnnotationQuery) UpdateAllSlice

func (q stackAnnotationQuery) UpdateAllSlice(o StackAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (stackAnnotationQuery) Upsert

func (q stackAnnotationQuery) Upsert(o *StackAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type stackAnnotationR

stackAnnotationR is where relationships are stored.

type stackAnnotationR struct {
    Resource *Stack `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*stackAnnotationR) NewStruct

func (*stackAnnotationR) NewStruct() *stackAnnotationR

NewStruct creates a new relationship struct

type stackL

stackL is where Load methods for each relationship are stored.

type stackL struct{}

func (stackL) LoadResourceStackAnnotations

func (stackL) LoadResourceStackAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeStack interface{}, mods queries.Applicator) error

LoadResourceStackAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (stackL) LoadResourceStackLabels

func (stackL) LoadResourceStackLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeStack interface{}, mods queries.Applicator) error

LoadResourceStackLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type stackLabelL

stackLabelL is where Load methods for each relationship are stored.

type stackLabelL struct{}

func (stackLabelL) LoadResource

func (stackLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeStackLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type stackLabelQuery

type stackLabelQuery struct {
    *queries.Query
}

func StackLabels

func StackLabels(mods ...qm.QueryMod) stackLabelQuery

StackLabels retrieves all the records using an executor.

func (stackLabelQuery) All

func (q stackLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (StackLabelSlice, error)

All returns all StackLabel records from the query.

func (stackLabelQuery) Count

func (q stackLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all StackLabel records in the query.

func (stackLabelQuery) Delete

func (q stackLabelQuery) Delete(o *StackLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single StackLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (stackLabelQuery) DeleteAll

func (q stackLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (stackLabelQuery) DeleteAllSlice

func (q stackLabelQuery) DeleteAllSlice(o StackLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (stackLabelQuery) Exists

func (q stackLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (stackLabelQuery) Insert

func (q stackLabelQuery) Insert(o *StackLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (stackLabelQuery) One

func (q stackLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*StackLabel, error)

One returns a single stackLabel record from the query.

func (stackLabelQuery) Reload

func (q stackLabelQuery) Reload(o *StackLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (stackLabelQuery) ReloadAll

func (q stackLabelQuery) ReloadAll(o *StackLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (stackLabelQuery) RemoveResource

func (q stackLabelQuery) RemoveResource(o *StackLabel, ctx context.Context, exec boil.ContextExecutor, related *Stack) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (stackLabelQuery) Resource

func (q stackLabelQuery) Resource(o *StackLabel, mods ...qm.QueryMod) stackQuery

Resource pointed to by the foreign key.

func (stackLabelQuery) SetResource

func (q stackLabelQuery) SetResource(o *StackLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Stack) error

SetResource of the stackLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceStackLabels.

func (stackLabelQuery) Update

func (q stackLabelQuery) Update(o *StackLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the StackLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (stackLabelQuery) UpdateAll

func (q stackLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (stackLabelQuery) UpdateAllSlice

func (q stackLabelQuery) UpdateAllSlice(o StackLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (stackLabelQuery) Upsert

func (q stackLabelQuery) Upsert(o *StackLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type stackLabelR

stackLabelR is where relationships are stored.

type stackLabelR struct {
    Resource *Stack `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*stackLabelR) NewStruct

func (*stackLabelR) NewStruct() *stackLabelR

NewStruct creates a new relationship struct

type stackQuery

type stackQuery struct {
    *queries.Query
}

func Stacks

func Stacks(mods ...qm.QueryMod) stackQuery

Stacks retrieves all the records using an executor.

func (stackQuery) AddResourceStackAnnotations

func (q stackQuery) AddResourceStackAnnotations(o *Stack, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*StackAnnotation) error

AddResourceStackAnnotations adds the given related objects to the existing relationships of the stack\, optionally inserting them as new records. Appends related to o.R.ResourceStackAnnotations. Sets related.R.Resource appropriately.

func (stackQuery) AddResourceStackLabels

func (q stackQuery) AddResourceStackLabels(o *Stack, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*StackLabel) error

AddResourceStackLabels adds the given related objects to the existing relationships of the stack\, optionally inserting them as new records. Appends related to o.R.ResourceStackLabels. Sets related.R.Resource appropriately.

func (stackQuery) All

func (q stackQuery) All(ctx context.Context, exec boil.ContextExecutor) (StackSlice, error)

All returns all Stack records from the query.

func (stackQuery) Count

func (q stackQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Stack records in the query.

func (stackQuery) Delete

func (q stackQuery) Delete(o *Stack, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Stack record with an executor. Delete will match against the primary key column to find the record to delete.

func (stackQuery) DeleteAll

func (q stackQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (stackQuery) DeleteAllSlice

func (q stackQuery) DeleteAllSlice(o StackSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (stackQuery) Exists

func (q stackQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (stackQuery) Insert

func (q stackQuery) Insert(o *Stack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (stackQuery) One

func (q stackQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Stack, error)

One returns a single stack record from the query.

func (stackQuery) Reload

func (q stackQuery) Reload(o *Stack, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (stackQuery) ReloadAll

func (q stackQuery) ReloadAll(o *StackSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (stackQuery) RemoveResourceStackAnnotations

func (q stackQuery) RemoveResourceStackAnnotations(o *Stack, ctx context.Context, exec boil.ContextExecutor, related ...*StackAnnotation) error

RemoveResourceStackAnnotations relationships from objects passed in. Removes related items from R.ResourceStackAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (stackQuery) RemoveResourceStackLabels

func (q stackQuery) RemoveResourceStackLabels(o *Stack, ctx context.Context, exec boil.ContextExecutor, related ...*StackLabel) error

RemoveResourceStackLabels relationships from objects passed in. Removes related items from R.ResourceStackLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (stackQuery) ResourceStackAnnotations

func (q stackQuery) ResourceStackAnnotations(o *Stack, mods ...qm.QueryMod) stackAnnotationQuery

ResourceStackAnnotations retrieves all the stack_annotation's StackAnnotations with an executor via resource_guid column.

func (stackQuery) ResourceStackLabels

func (q stackQuery) ResourceStackLabels(o *Stack, mods ...qm.QueryMod) stackLabelQuery

ResourceStackLabels retrieves all the stack_label's StackLabels with an executor via resource_guid column.

func (stackQuery) SetResourceStackAnnotations

func (q stackQuery) SetResourceStackAnnotations(o *Stack, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*StackAnnotation) error

SetResourceStackAnnotations removes all previously related items of the stack replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceStackAnnotations accordingly. Replaces o.R.ResourceStackAnnotations with related. Sets related.R.Resource's ResourceStackAnnotations accordingly.

func (stackQuery) SetResourceStackLabels

func (q stackQuery) SetResourceStackLabels(o *Stack, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*StackLabel) error

SetResourceStackLabels removes all previously related items of the stack replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceStackLabels accordingly. Replaces o.R.ResourceStackLabels with related. Sets related.R.Resource's ResourceStackLabels accordingly.

func (stackQuery) Update

func (q stackQuery) Update(o *Stack, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Stack. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (stackQuery) UpdateAll

func (q stackQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (stackQuery) UpdateAllSlice

func (q stackQuery) UpdateAllSlice(o StackSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (stackQuery) Upsert

func (q stackQuery) Upsert(o *Stack, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type stackR

stackR is where relationships are stored.

type stackR struct {
    ResourceStackAnnotations StackAnnotationSlice `boil:"ResourceStackAnnotations" json:"ResourceStackAnnotations" toml:"ResourceStackAnnotations" yaml:"ResourceStackAnnotations"`
    ResourceStackLabels      StackLabelSlice      `boil:"ResourceStackLabels" json:"ResourceStackLabels" toml:"ResourceStackLabels" yaml:"ResourceStackLabels"`
}

func (*stackR) NewStruct

func (*stackR) NewStruct() *stackR

NewStruct creates a new relationship struct

type stagingSecurityGroupsSpaceL

stagingSecurityGroupsSpaceL is where Load methods for each relationship are stored.

type stagingSecurityGroupsSpaceL struct{}

func (stagingSecurityGroupsSpaceL) LoadStagingSecurityGroup

func (stagingSecurityGroupsSpaceL) LoadStagingSecurityGroup(ctx context.Context, e boil.ContextExecutor, singular bool, maybeStagingSecurityGroupsSpace interface{}, mods queries.Applicator) error

LoadStagingSecurityGroup allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (stagingSecurityGroupsSpaceL) LoadStagingSpace

func (stagingSecurityGroupsSpaceL) LoadStagingSpace(ctx context.Context, e boil.ContextExecutor, singular bool, maybeStagingSecurityGroupsSpace interface{}, mods queries.Applicator) error

LoadStagingSpace allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type stagingSecurityGroupsSpaceQuery

type stagingSecurityGroupsSpaceQuery struct {
    *queries.Query
}

func StagingSecurityGroupsSpaces

func StagingSecurityGroupsSpaces(mods ...qm.QueryMod) stagingSecurityGroupsSpaceQuery

StagingSecurityGroupsSpaces retrieves all the records using an executor.

func (stagingSecurityGroupsSpaceQuery) All

func (q stagingSecurityGroupsSpaceQuery) All(ctx context.Context, exec boil.ContextExecutor) (StagingSecurityGroupsSpaceSlice, error)

All returns all StagingSecurityGroupsSpace records from the query.

func (stagingSecurityGroupsSpaceQuery) Count

func (q stagingSecurityGroupsSpaceQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all StagingSecurityGroupsSpace records in the query.

func (stagingSecurityGroupsSpaceQuery) Delete

func (q stagingSecurityGroupsSpaceQuery) Delete(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single StagingSecurityGroupsSpace record with an executor. Delete will match against the primary key column to find the record to delete.

func (stagingSecurityGroupsSpaceQuery) DeleteAll

func (q stagingSecurityGroupsSpaceQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (stagingSecurityGroupsSpaceQuery) DeleteAllSlice

func (q stagingSecurityGroupsSpaceQuery) DeleteAllSlice(o StagingSecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (stagingSecurityGroupsSpaceQuery) Exists

func (q stagingSecurityGroupsSpaceQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (stagingSecurityGroupsSpaceQuery) Insert

func (q stagingSecurityGroupsSpaceQuery) Insert(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (stagingSecurityGroupsSpaceQuery) One

func (q stagingSecurityGroupsSpaceQuery) One(ctx context.Context, exec boil.ContextExecutor) (*StagingSecurityGroupsSpace, error)

One returns a single stagingSecurityGroupsSpace record from the query.

func (stagingSecurityGroupsSpaceQuery) Reload

func (q stagingSecurityGroupsSpaceQuery) Reload(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (stagingSecurityGroupsSpaceQuery) ReloadAll

func (q stagingSecurityGroupsSpaceQuery) ReloadAll(o *StagingSecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (stagingSecurityGroupsSpaceQuery) SetStagingSecurityGroup

func (q stagingSecurityGroupsSpaceQuery) SetStagingSecurityGroup(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, insert bool, related *SecurityGroup) error

SetStagingSecurityGroup of the stagingSecurityGroupsSpace to the related item. Sets o.R.StagingSecurityGroup to related. Adds o to related.R.StagingSecurityGroupStagingSecurityGroupsSpaces.

func (stagingSecurityGroupsSpaceQuery) SetStagingSpace

func (q stagingSecurityGroupsSpaceQuery) SetStagingSpace(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetStagingSpace of the stagingSecurityGroupsSpace to the related item. Sets o.R.StagingSpace to related. Adds o to related.R.StagingSpaceStagingSecurityGroupsSpaces.

func (stagingSecurityGroupsSpaceQuery) StagingSecurityGroup

func (q stagingSecurityGroupsSpaceQuery) StagingSecurityGroup(o *StagingSecurityGroupsSpace, mods ...qm.QueryMod) securityGroupQuery

StagingSecurityGroup pointed to by the foreign key.

func (stagingSecurityGroupsSpaceQuery) StagingSpace

func (q stagingSecurityGroupsSpaceQuery) StagingSpace(o *StagingSecurityGroupsSpace, mods ...qm.QueryMod) spaceQuery

StagingSpace pointed to by the foreign key.

func (stagingSecurityGroupsSpaceQuery) Update

func (q stagingSecurityGroupsSpaceQuery) Update(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the StagingSecurityGroupsSpace. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (stagingSecurityGroupsSpaceQuery) UpdateAll

func (q stagingSecurityGroupsSpaceQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (stagingSecurityGroupsSpaceQuery) UpdateAllSlice

func (q stagingSecurityGroupsSpaceQuery) UpdateAllSlice(o StagingSecurityGroupsSpaceSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (stagingSecurityGroupsSpaceQuery) Upsert

func (q stagingSecurityGroupsSpaceQuery) Upsert(o *StagingSecurityGroupsSpace, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type stagingSecurityGroupsSpaceR

stagingSecurityGroupsSpaceR is where relationships are stored.

type stagingSecurityGroupsSpaceR struct {
    StagingSecurityGroup *SecurityGroup `boil:"StagingSecurityGroup" json:"StagingSecurityGroup" toml:"StagingSecurityGroup" yaml:"StagingSecurityGroup"`
    StagingSpace         *Space         `boil:"StagingSpace" json:"StagingSpace" toml:"StagingSpace" yaml:"StagingSpace"`
}

func (*stagingSecurityGroupsSpaceR) NewStruct

func (*stagingSecurityGroupsSpaceR) NewStruct() *stagingSecurityGroupsSpaceR

NewStruct creates a new relationship struct

type taskAnnotationL

taskAnnotationL is where Load methods for each relationship are stored.

type taskAnnotationL struct{}

func (taskAnnotationL) LoadResource

func (taskAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeTaskAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type taskAnnotationQuery

type taskAnnotationQuery struct {
    *queries.Query
}

func TaskAnnotations

func TaskAnnotations(mods ...qm.QueryMod) taskAnnotationQuery

TaskAnnotations retrieves all the records using an executor.

func (taskAnnotationQuery) All

func (q taskAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (TaskAnnotationSlice, error)

All returns all TaskAnnotation records from the query.

func (taskAnnotationQuery) Count

func (q taskAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all TaskAnnotation records in the query.

func (taskAnnotationQuery) Delete

func (q taskAnnotationQuery) Delete(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single TaskAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (taskAnnotationQuery) DeleteAll

func (q taskAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (taskAnnotationQuery) DeleteAllSlice

func (q taskAnnotationQuery) DeleteAllSlice(o TaskAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (taskAnnotationQuery) Exists

func (q taskAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (taskAnnotationQuery) Insert

func (q taskAnnotationQuery) Insert(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (taskAnnotationQuery) One

func (q taskAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*TaskAnnotation, error)

One returns a single taskAnnotation record from the query.

func (taskAnnotationQuery) Reload

func (q taskAnnotationQuery) Reload(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (taskAnnotationQuery) ReloadAll

func (q taskAnnotationQuery) ReloadAll(o *TaskAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (taskAnnotationQuery) RemoveResource

func (q taskAnnotationQuery) RemoveResource(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor, related *Task) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (taskAnnotationQuery) Resource

func (q taskAnnotationQuery) Resource(o *TaskAnnotation, mods ...qm.QueryMod) taskQuery

Resource pointed to by the foreign key.

func (taskAnnotationQuery) SetResource

func (q taskAnnotationQuery) SetResource(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Task) error

SetResource of the taskAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceTaskAnnotations.

func (taskAnnotationQuery) Update

func (q taskAnnotationQuery) Update(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the TaskAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (taskAnnotationQuery) UpdateAll

func (q taskAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (taskAnnotationQuery) UpdateAllSlice

func (q taskAnnotationQuery) UpdateAllSlice(o TaskAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (taskAnnotationQuery) Upsert

func (q taskAnnotationQuery) Upsert(o *TaskAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type taskAnnotationR

taskAnnotationR is where relationships are stored.

type taskAnnotationR struct {
    Resource *Task `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*taskAnnotationR) NewStruct

func (*taskAnnotationR) NewStruct() *taskAnnotationR

NewStruct creates a new relationship struct

type taskL

taskL is where Load methods for each relationship are stored.

type taskL struct{}

func (taskL) LoadApp

func (taskL) LoadApp(ctx context.Context, e boil.ContextExecutor, singular bool, maybeTask interface{}, mods queries.Applicator) error

LoadApp allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (taskL) LoadResourceTaskAnnotations

func (taskL) LoadResourceTaskAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeTask interface{}, mods queries.Applicator) error

LoadResourceTaskAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (taskL) LoadResourceTaskLabels

func (taskL) LoadResourceTaskLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeTask interface{}, mods queries.Applicator) error

LoadResourceTaskLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type taskLabelL

taskLabelL is where Load methods for each relationship are stored.

type taskLabelL struct{}

func (taskLabelL) LoadResource

func (taskLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeTaskLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type taskLabelQuery

type taskLabelQuery struct {
    *queries.Query
}

func TaskLabels

func TaskLabels(mods ...qm.QueryMod) taskLabelQuery

TaskLabels retrieves all the records using an executor.

func (taskLabelQuery) All

func (q taskLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (TaskLabelSlice, error)

All returns all TaskLabel records from the query.

func (taskLabelQuery) Count

func (q taskLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all TaskLabel records in the query.

func (taskLabelQuery) Delete

func (q taskLabelQuery) Delete(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single TaskLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (taskLabelQuery) DeleteAll

func (q taskLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (taskLabelQuery) DeleteAllSlice

func (q taskLabelQuery) DeleteAllSlice(o TaskLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (taskLabelQuery) Exists

func (q taskLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (taskLabelQuery) Insert

func (q taskLabelQuery) Insert(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (taskLabelQuery) One

func (q taskLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*TaskLabel, error)

One returns a single taskLabel record from the query.

func (taskLabelQuery) Reload

func (q taskLabelQuery) Reload(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (taskLabelQuery) ReloadAll

func (q taskLabelQuery) ReloadAll(o *TaskLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (taskLabelQuery) RemoveResource

func (q taskLabelQuery) RemoveResource(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor, related *Task) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (taskLabelQuery) Resource

func (q taskLabelQuery) Resource(o *TaskLabel, mods ...qm.QueryMod) taskQuery

Resource pointed to by the foreign key.

func (taskLabelQuery) SetResource

func (q taskLabelQuery) SetResource(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Task) error

SetResource of the taskLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceTaskLabels.

func (taskLabelQuery) Update

func (q taskLabelQuery) Update(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the TaskLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (taskLabelQuery) UpdateAll

func (q taskLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (taskLabelQuery) UpdateAllSlice

func (q taskLabelQuery) UpdateAllSlice(o TaskLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (taskLabelQuery) Upsert

func (q taskLabelQuery) Upsert(o *TaskLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type taskLabelR

taskLabelR is where relationships are stored.

type taskLabelR struct {
    Resource *Task `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*taskLabelR) NewStruct

func (*taskLabelR) NewStruct() *taskLabelR

NewStruct creates a new relationship struct

type taskQuery

type taskQuery struct {
    *queries.Query
}

func Tasks

func Tasks(mods ...qm.QueryMod) taskQuery

Tasks retrieves all the records using an executor.

func (taskQuery) AddResourceTaskAnnotations

func (q taskQuery) AddResourceTaskAnnotations(o *Task, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*TaskAnnotation) error

AddResourceTaskAnnotations adds the given related objects to the existing relationships of the task\, optionally inserting them as new records. Appends related to o.R.ResourceTaskAnnotations. Sets related.R.Resource appropriately.

func (taskQuery) AddResourceTaskLabels

func (q taskQuery) AddResourceTaskLabels(o *Task, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*TaskLabel) error

AddResourceTaskLabels adds the given related objects to the existing relationships of the task\, optionally inserting them as new records. Appends related to o.R.ResourceTaskLabels. Sets related.R.Resource appropriately.

func (taskQuery) All

func (q taskQuery) All(ctx context.Context, exec boil.ContextExecutor) (TaskSlice, error)

All returns all Task records from the query.

func (taskQuery) App

func (q taskQuery) App(o *Task, mods ...qm.QueryMod) appQuery

App pointed to by the foreign key.

func (taskQuery) Count

func (q taskQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all Task records in the query.

func (taskQuery) Delete

func (q taskQuery) Delete(o *Task, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single Task record with an executor. Delete will match against the primary key column to find the record to delete.

func (taskQuery) DeleteAll

func (q taskQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (taskQuery) DeleteAllSlice

func (q taskQuery) DeleteAllSlice(o TaskSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (taskQuery) Exists

func (q taskQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (taskQuery) Insert

func (q taskQuery) Insert(o *Task, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (taskQuery) One

func (q taskQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Task, error)

One returns a single task record from the query.

func (taskQuery) Reload

func (q taskQuery) Reload(o *Task, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (taskQuery) ReloadAll

func (q taskQuery) ReloadAll(o *TaskSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (taskQuery) RemoveResourceTaskAnnotations

func (q taskQuery) RemoveResourceTaskAnnotations(o *Task, ctx context.Context, exec boil.ContextExecutor, related ...*TaskAnnotation) error

RemoveResourceTaskAnnotations relationships from objects passed in. Removes related items from R.ResourceTaskAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (taskQuery) RemoveResourceTaskLabels

func (q taskQuery) RemoveResourceTaskLabels(o *Task, ctx context.Context, exec boil.ContextExecutor, related ...*TaskLabel) error

RemoveResourceTaskLabels relationships from objects passed in. Removes related items from R.ResourceTaskLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (taskQuery) ResourceTaskAnnotations

func (q taskQuery) ResourceTaskAnnotations(o *Task, mods ...qm.QueryMod) taskAnnotationQuery

ResourceTaskAnnotations retrieves all the task_annotation's TaskAnnotations with an executor via resource_guid column.

func (taskQuery) ResourceTaskLabels

func (q taskQuery) ResourceTaskLabels(o *Task, mods ...qm.QueryMod) taskLabelQuery

ResourceTaskLabels retrieves all the task_label's TaskLabels with an executor via resource_guid column.

func (taskQuery) SetApp

func (q taskQuery) SetApp(o *Task, ctx context.Context, exec boil.ContextExecutor, insert bool, related *App) error

SetApp of the task to the related item. Sets o.R.App to related. Adds o to related.R.Tasks.

func (taskQuery) SetResourceTaskAnnotations

func (q taskQuery) SetResourceTaskAnnotations(o *Task, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*TaskAnnotation) error

SetResourceTaskAnnotations removes all previously related items of the task replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceTaskAnnotations accordingly. Replaces o.R.ResourceTaskAnnotations with related. Sets related.R.Resource's ResourceTaskAnnotations accordingly.

func (taskQuery) SetResourceTaskLabels

func (q taskQuery) SetResourceTaskLabels(o *Task, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*TaskLabel) error

SetResourceTaskLabels removes all previously related items of the task replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceTaskLabels accordingly. Replaces o.R.ResourceTaskLabels with related. Sets related.R.Resource's ResourceTaskLabels accordingly.

func (taskQuery) Update

func (q taskQuery) Update(o *Task, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the Task. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (taskQuery) UpdateAll

func (q taskQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (taskQuery) UpdateAllSlice

func (q taskQuery) UpdateAllSlice(o TaskSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (taskQuery) Upsert

func (q taskQuery) Upsert(o *Task, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type taskR

taskR is where relationships are stored.

type taskR struct {
    App                     *App                `boil:"App" json:"App" toml:"App" yaml:"App"`
    ResourceTaskAnnotations TaskAnnotationSlice `boil:"ResourceTaskAnnotations" json:"ResourceTaskAnnotations" toml:"ResourceTaskAnnotations" yaml:"ResourceTaskAnnotations"`
    ResourceTaskLabels      TaskLabelSlice      `boil:"ResourceTaskLabels" json:"ResourceTaskLabels" toml:"ResourceTaskLabels" yaml:"ResourceTaskLabels"`
}

func (*taskR) NewStruct

func (*taskR) NewStruct() *taskR

NewStruct creates a new relationship struct

type updateCache

type updateCache struct {
    query        string
    valueMapping []uint64
}

type userAnnotationL

userAnnotationL is where Load methods for each relationship are stored.

type userAnnotationL struct{}

func (userAnnotationL) LoadResource

func (userAnnotationL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUserAnnotation interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type userAnnotationQuery

type userAnnotationQuery struct {
    *queries.Query
}

func UserAnnotations

func UserAnnotations(mods ...qm.QueryMod) userAnnotationQuery

UserAnnotations retrieves all the records using an executor.

func (userAnnotationQuery) All

func (q userAnnotationQuery) All(ctx context.Context, exec boil.ContextExecutor) (UserAnnotationSlice, error)

All returns all UserAnnotation records from the query.

func (userAnnotationQuery) Count

func (q userAnnotationQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all UserAnnotation records in the query.

func (userAnnotationQuery) Delete

func (q userAnnotationQuery) Delete(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single UserAnnotation record with an executor. Delete will match against the primary key column to find the record to delete.

func (userAnnotationQuery) DeleteAll

func (q userAnnotationQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (userAnnotationQuery) DeleteAllSlice

func (q userAnnotationQuery) DeleteAllSlice(o UserAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (userAnnotationQuery) Exists

func (q userAnnotationQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (userAnnotationQuery) Insert

func (q userAnnotationQuery) Insert(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (userAnnotationQuery) One

func (q userAnnotationQuery) One(ctx context.Context, exec boil.ContextExecutor) (*UserAnnotation, error)

One returns a single userAnnotation record from the query.

func (userAnnotationQuery) Reload

func (q userAnnotationQuery) Reload(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (userAnnotationQuery) ReloadAll

func (q userAnnotationQuery) ReloadAll(o *UserAnnotationSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (userAnnotationQuery) RemoveResource

func (q userAnnotationQuery) RemoveResource(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor, related *User) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (userAnnotationQuery) Resource

func (q userAnnotationQuery) Resource(o *UserAnnotation, mods ...qm.QueryMod) userQuery

Resource pointed to by the foreign key.

func (userAnnotationQuery) SetResource

func (q userAnnotationQuery) SetResource(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor, insert bool, related *User) error

SetResource of the userAnnotation to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceUserAnnotations.

func (userAnnotationQuery) Update

func (q userAnnotationQuery) Update(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the UserAnnotation. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (userAnnotationQuery) UpdateAll

func (q userAnnotationQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (userAnnotationQuery) UpdateAllSlice

func (q userAnnotationQuery) UpdateAllSlice(o UserAnnotationSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (userAnnotationQuery) Upsert

func (q userAnnotationQuery) Upsert(o *UserAnnotation, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type userAnnotationR

userAnnotationR is where relationships are stored.

type userAnnotationR struct {
    Resource *User `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*userAnnotationR) NewStruct

func (*userAnnotationR) NewStruct() *userAnnotationR

NewStruct creates a new relationship struct

type userL

userL is where Load methods for each relationship are stored.

type userL struct{}

func (userL) LoadDefaultSpace

func (userL) LoadDefaultSpace(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUser interface{}, mods queries.Applicator) error

LoadDefaultSpace allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

func (userL) LoadOrganizationsAuditors

func (userL) LoadOrganizationsAuditors(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUser interface{}, mods queries.Applicator) error

LoadOrganizationsAuditors allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (userL) LoadOrganizationsBillingManagers

func (userL) LoadOrganizationsBillingManagers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUser interface{}, mods queries.Applicator) error

LoadOrganizationsBillingManagers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (userL) LoadOrganizationsManagers

func (userL) LoadOrganizationsManagers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUser interface{}, mods queries.Applicator) error

LoadOrganizationsManagers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (userL) LoadOrganizationsUsers

func (userL) LoadOrganizationsUsers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUser interface{}, mods queries.Applicator) error

LoadOrganizationsUsers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (userL) LoadResourceUserAnnotations

func (userL) LoadResourceUserAnnotations(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUser interface{}, mods queries.Applicator) error

LoadResourceUserAnnotations allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (userL) LoadResourceUserLabels

func (userL) LoadResourceUserLabels(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUser interface{}, mods queries.Applicator) error

LoadResourceUserLabels allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (userL) LoadSpacesApplicationSupporters

func (userL) LoadSpacesApplicationSupporters(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUser interface{}, mods queries.Applicator) error

LoadSpacesApplicationSupporters allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (userL) LoadSpacesAuditors

func (userL) LoadSpacesAuditors(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUser interface{}, mods queries.Applicator) error

LoadSpacesAuditors allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (userL) LoadSpacesDevelopers

func (userL) LoadSpacesDevelopers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUser interface{}, mods queries.Applicator) error

LoadSpacesDevelopers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

func (userL) LoadSpacesManagers

func (userL) LoadSpacesManagers(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUser interface{}, mods queries.Applicator) error

LoadSpacesManagers allows an eager lookup of values\, cached into the loaded structs of the objects. This is for a 1-M or N-M relationship.

type userLabelL

userLabelL is where Load methods for each relationship are stored.

type userLabelL struct{}

func (userLabelL) LoadResource

func (userLabelL) LoadResource(ctx context.Context, e boil.ContextExecutor, singular bool, maybeUserLabel interface{}, mods queries.Applicator) error

LoadResource allows an eager lookup of values\, cached into the loaded structs of the objects. This is for an N-1 relationship.

type userLabelQuery

type userLabelQuery struct {
    *queries.Query
}

func UserLabels

func UserLabels(mods ...qm.QueryMod) userLabelQuery

UserLabels retrieves all the records using an executor.

func (userLabelQuery) All

func (q userLabelQuery) All(ctx context.Context, exec boil.ContextExecutor) (UserLabelSlice, error)

All returns all UserLabel records from the query.

func (userLabelQuery) Count

func (q userLabelQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all UserLabel records in the query.

func (userLabelQuery) Delete

func (q userLabelQuery) Delete(o *UserLabel, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single UserLabel record with an executor. Delete will match against the primary key column to find the record to delete.

func (userLabelQuery) DeleteAll

func (q userLabelQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (userLabelQuery) DeleteAllSlice

func (q userLabelQuery) DeleteAllSlice(o UserLabelSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (userLabelQuery) Exists

func (q userLabelQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (userLabelQuery) Insert

func (q userLabelQuery) Insert(o *UserLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (userLabelQuery) One

func (q userLabelQuery) One(ctx context.Context, exec boil.ContextExecutor) (*UserLabel, error)

One returns a single userLabel record from the query.

func (userLabelQuery) Reload

func (q userLabelQuery) Reload(o *UserLabel, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (userLabelQuery) ReloadAll

func (q userLabelQuery) ReloadAll(o *UserLabelSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (userLabelQuery) RemoveResource

func (q userLabelQuery) RemoveResource(o *UserLabel, ctx context.Context, exec boil.ContextExecutor, related *User) error

RemoveResource relationship. Sets o.R.Resource to nil. Removes o from all passed in related items' relationships struct (Optional).

func (userLabelQuery) Resource

func (q userLabelQuery) Resource(o *UserLabel, mods ...qm.QueryMod) userQuery

Resource pointed to by the foreign key.

func (userLabelQuery) SetResource

func (q userLabelQuery) SetResource(o *UserLabel, ctx context.Context, exec boil.ContextExecutor, insert bool, related *User) error

SetResource of the userLabel to the related item. Sets o.R.Resource to related. Adds o to related.R.ResourceUserLabels.

func (userLabelQuery) Update

func (q userLabelQuery) Update(o *UserLabel, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the UserLabel. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (userLabelQuery) UpdateAll

func (q userLabelQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (userLabelQuery) UpdateAllSlice

func (q userLabelQuery) UpdateAllSlice(o UserLabelSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (userLabelQuery) Upsert

func (q userLabelQuery) Upsert(o *UserLabel, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type userLabelR

userLabelR is where relationships are stored.

type userLabelR struct {
    Resource *User `boil:"Resource" json:"Resource" toml:"Resource" yaml:"Resource"`
}

func (*userLabelR) NewStruct

func (*userLabelR) NewStruct() *userLabelR

NewStruct creates a new relationship struct

type userQuery

type userQuery struct {
    *queries.Query
}

func Users

func Users(mods ...qm.QueryMod) userQuery

Users retrieves all the records using an executor.

func (userQuery) AddOrganizationsAuditors

func (q userQuery) AddOrganizationsAuditors(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationsAuditor) error

AddOrganizationsAuditors adds the given related objects to the existing relationships of the user\, optionally inserting them as new records. Appends related to o.R.OrganizationsAuditors. Sets related.R.User appropriately.

func (userQuery) AddOrganizationsBillingManagers

func (q userQuery) AddOrganizationsBillingManagers(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationsBillingManager) error

AddOrganizationsBillingManagers adds the given related objects to the existing relationships of the user\, optionally inserting them as new records. Appends related to o.R.OrganizationsBillingManagers. Sets related.R.User appropriately.

func (userQuery) AddOrganizationsManagers

func (q userQuery) AddOrganizationsManagers(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationsManager) error

AddOrganizationsManagers adds the given related objects to the existing relationships of the user\, optionally inserting them as new records. Appends related to o.R.OrganizationsManagers. Sets related.R.User appropriately.

func (userQuery) AddOrganizationsUsers

func (q userQuery) AddOrganizationsUsers(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*OrganizationsUser) error

AddOrganizationsUsers adds the given related objects to the existing relationships of the user\, optionally inserting them as new records. Appends related to o.R.OrganizationsUsers. Sets related.R.User appropriately.

func (userQuery) AddResourceUserAnnotations

func (q userQuery) AddResourceUserAnnotations(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*UserAnnotation) error

AddResourceUserAnnotations adds the given related objects to the existing relationships of the user\, optionally inserting them as new records. Appends related to o.R.ResourceUserAnnotations. Sets related.R.Resource appropriately.

func (userQuery) AddResourceUserLabels

func (q userQuery) AddResourceUserLabels(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*UserLabel) error

AddResourceUserLabels adds the given related objects to the existing relationships of the user\, optionally inserting them as new records. Appends related to o.R.ResourceUserLabels. Sets related.R.Resource appropriately.

func (userQuery) AddSpacesApplicationSupporters

func (q userQuery) AddSpacesApplicationSupporters(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpacesApplicationSupporter) error

AddSpacesApplicationSupporters adds the given related objects to the existing relationships of the user\, optionally inserting them as new records. Appends related to o.R.SpacesApplicationSupporters. Sets related.R.User appropriately.

func (userQuery) AddSpacesAuditors

func (q userQuery) AddSpacesAuditors(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpacesAuditor) error

AddSpacesAuditors adds the given related objects to the existing relationships of the user\, optionally inserting them as new records. Appends related to o.R.SpacesAuditors. Sets related.R.User appropriately.

func (userQuery) AddSpacesDevelopers

func (q userQuery) AddSpacesDevelopers(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpacesDeveloper) error

AddSpacesDevelopers adds the given related objects to the existing relationships of the user\, optionally inserting them as new records. Appends related to o.R.SpacesDevelopers. Sets related.R.User appropriately.

func (userQuery) AddSpacesManagers

func (q userQuery) AddSpacesManagers(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*SpacesManager) error

AddSpacesManagers adds the given related objects to the existing relationships of the user\, optionally inserting them as new records. Appends related to o.R.SpacesManagers. Sets related.R.User appropriately.

func (userQuery) All

func (q userQuery) All(ctx context.Context, exec boil.ContextExecutor) (UserSlice, error)

All returns all User records from the query.

func (userQuery) Count

func (q userQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error)

Count returns the count of all User records in the query.

func (userQuery) DefaultSpace

func (q userQuery) DefaultSpace(o *User, mods ...qm.QueryMod) spaceQuery

DefaultSpace pointed to by the foreign key.

func (userQuery) Delete

func (q userQuery) Delete(o *User, ctx context.Context, exec boil.ContextExecutor) (int64, error)

Delete deletes a single User record with an executor. Delete will match against the primary key column to find the record to delete.

func (userQuery) DeleteAll

func (q userQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all matching rows.

func (userQuery) DeleteAllSlice

func (q userQuery) DeleteAllSlice(o UserSlice, ctx context.Context, exec boil.ContextExecutor) (int64, error)

DeleteAll deletes all rows in the slice\, using an executor.

func (userQuery) Exists

func (q userQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error)

Exists checks if the row exists in the table.

func (userQuery) Insert

func (q userQuery) Insert(o *User, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error

Insert a single record using an executor. See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.

func (userQuery) One

func (q userQuery) One(ctx context.Context, exec boil.ContextExecutor) (*User, error)

One returns a single user record from the query.

func (userQuery) OrganizationsAuditors

func (q userQuery) OrganizationsAuditors(o *User, mods ...qm.QueryMod) organizationsAuditorQuery

OrganizationsAuditors retrieves all the organizations_auditor's OrganizationsAuditors with an executor.

func (userQuery) OrganizationsBillingManagers

func (q userQuery) OrganizationsBillingManagers(o *User, mods ...qm.QueryMod) organizationsBillingManagerQuery

OrganizationsBillingManagers retrieves all the organizations_billing_manager's OrganizationsBillingManagers with an executor.

func (userQuery) OrganizationsManagers

func (q userQuery) OrganizationsManagers(o *User, mods ...qm.QueryMod) organizationsManagerQuery

OrganizationsManagers retrieves all the organizations_manager's OrganizationsManagers with an executor.

func (userQuery) OrganizationsUsers

func (q userQuery) OrganizationsUsers(o *User, mods ...qm.QueryMod) organizationsUserQuery

OrganizationsUsers retrieves all the organizations_user's OrganizationsUsers with an executor.

func (userQuery) Reload

func (q userQuery) Reload(o *User, ctx context.Context, exec boil.ContextExecutor) error

Reload refetches the object from the database using the primary keys with an executor.

func (userQuery) ReloadAll

func (q userQuery) ReloadAll(o *UserSlice, ctx context.Context, exec boil.ContextExecutor) error

ReloadAll refetches every row with matching primary key column values and overwrites the original object slice with the newly updated slice.

func (userQuery) RemoveDefaultSpace

func (q userQuery) RemoveDefaultSpace(o *User, ctx context.Context, exec boil.ContextExecutor, related *Space) error

RemoveDefaultSpace relationship. Sets o.R.DefaultSpace to nil. Removes o from all passed in related items' relationships struct (Optional).

func (userQuery) RemoveResourceUserAnnotations

func (q userQuery) RemoveResourceUserAnnotations(o *User, ctx context.Context, exec boil.ContextExecutor, related ...*UserAnnotation) error

RemoveResourceUserAnnotations relationships from objects passed in. Removes related items from R.ResourceUserAnnotations (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (userQuery) RemoveResourceUserLabels

func (q userQuery) RemoveResourceUserLabels(o *User, ctx context.Context, exec boil.ContextExecutor, related ...*UserLabel) error

RemoveResourceUserLabels relationships from objects passed in. Removes related items from R.ResourceUserLabels (uses pointer comparison\, removal does not keep order) Sets related.R.Resource.

func (userQuery) ResourceUserAnnotations

func (q userQuery) ResourceUserAnnotations(o *User, mods ...qm.QueryMod) userAnnotationQuery

ResourceUserAnnotations retrieves all the user_annotation's UserAnnotations with an executor via resource_guid column.

func (userQuery) ResourceUserLabels

func (q userQuery) ResourceUserLabels(o *User, mods ...qm.QueryMod) userLabelQuery

ResourceUserLabels retrieves all the user_label's UserLabels with an executor via resource_guid column.

func (userQuery) SetDefaultSpace

func (q userQuery) SetDefaultSpace(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related *Space) error

SetDefaultSpace of the user to the related item. Sets o.R.DefaultSpace to related. Adds o to related.R.DefaultSpaceUsers.

func (userQuery) SetResourceUserAnnotations

func (q userQuery) SetResourceUserAnnotations(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*UserAnnotation) error

SetResourceUserAnnotations removes all previously related items of the user replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceUserAnnotations accordingly. Replaces o.R.ResourceUserAnnotations with related. Sets related.R.Resource's ResourceUserAnnotations accordingly.

func (userQuery) SetResourceUserLabels

func (q userQuery) SetResourceUserLabels(o *User, ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*UserLabel) error

SetResourceUserLabels removes all previously related items of the user replacing them completely with the passed in related items\, optionally inserting them as new records. Sets o.R.Resource's ResourceUserLabels accordingly. Replaces o.R.ResourceUserLabels with related. Sets related.R.Resource's ResourceUserLabels accordingly.

func (userQuery) SpacesApplicationSupporters

func (q userQuery) SpacesApplicationSupporters(o *User, mods ...qm.QueryMod) spacesApplicationSupporterQuery

SpacesApplicationSupporters retrieves all the spaces_application_supporter's SpacesApplicationSupporters with an executor.

func (userQuery) SpacesAuditors

func (q userQuery) SpacesAuditors(o *User, mods ...qm.QueryMod) spacesAuditorQuery

SpacesAuditors retrieves all the spaces_auditor's SpacesAuditors with an executor.

func (userQuery) SpacesDevelopers

func (q userQuery) SpacesDevelopers(o *User, mods ...qm.QueryMod) spacesDeveloperQuery

SpacesDevelopers retrieves all the spaces_developer's SpacesDevelopers with an executor.

func (userQuery) SpacesManagers

func (q userQuery) SpacesManagers(o *User, mods ...qm.QueryMod) spacesManagerQuery

SpacesManagers retrieves all the spaces_manager's SpacesManagers with an executor.

func (userQuery) Update

func (q userQuery) Update(o *User, ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error)

Update uses an executor to update the User. See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.

func (userQuery) UpdateAll

func (q userQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values.

func (userQuery) UpdateAllSlice

func (q userQuery) UpdateAllSlice(o UserSlice, ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error)

UpdateAll updates all rows with the specified column values\, using an executor.

func (userQuery) Upsert

func (q userQuery) Upsert(o *User, ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error

Upsert attempts an insert using an executor\, and does an update or ignore on conflict. See boil.Columns documentation for how to properly use updateColumns and insertColumns.

type userR

userR is where relationships are stored.

type userR struct {
    DefaultSpace                 *Space                           `boil:"DefaultSpace" json:"DefaultSpace" toml:"DefaultSpace" yaml:"DefaultSpace"`
    OrganizationsAuditors        OrganizationsAuditorSlice        `boil:"OrganizationsAuditors" json:"OrganizationsAuditors" toml:"OrganizationsAuditors" yaml:"OrganizationsAuditors"`
    OrganizationsBillingManagers OrganizationsBillingManagerSlice `boil:"OrganizationsBillingManagers" json:"OrganizationsBillingManagers" toml:"OrganizationsBillingManagers" yaml:"OrganizationsBillingManagers"`
    OrganizationsManagers        OrganizationsManagerSlice        `boil:"OrganizationsManagers" json:"OrganizationsManagers" toml:"OrganizationsManagers" yaml:"OrganizationsManagers"`
    OrganizationsUsers           OrganizationsUserSlice           `boil:"OrganizationsUsers" json:"OrganizationsUsers" toml:"OrganizationsUsers" yaml:"OrganizationsUsers"`
    SpacesApplicationSupporters  SpacesApplicationSupporterSlice  `boil:"SpacesApplicationSupporters" json:"SpacesApplicationSupporters" toml:"SpacesApplicationSupporters" yaml:"SpacesApplicationSupporters"`
    SpacesAuditors               SpacesAuditorSlice               `boil:"SpacesAuditors" json:"SpacesAuditors" toml:"SpacesAuditors" yaml:"SpacesAuditors"`
    SpacesDevelopers             SpacesDeveloperSlice             `boil:"SpacesDevelopers" json:"SpacesDevelopers" toml:"SpacesDevelopers" yaml:"SpacesDevelopers"`
    SpacesManagers               SpacesManagerSlice               `boil:"SpacesManagers" json:"SpacesManagers" toml:"SpacesManagers" yaml:"SpacesManagers"`
    ResourceUserAnnotations      UserAnnotationSlice              `boil:"ResourceUserAnnotations" json:"ResourceUserAnnotations" toml:"ResourceUserAnnotations" yaml:"ResourceUserAnnotations"`
    ResourceUserLabels           UserLabelSlice                   `boil:"ResourceUserLabels" json:"ResourceUserLabels" toml:"ResourceUserLabels" yaml:"ResourceUserLabels"`
}

func (*userR) NewStruct

func (*userR) NewStruct() *userR

NewStruct creates a new relationship struct

type whereHelperbool

type whereHelperbool struct{ field string }

func (whereHelperbool) EQ

func (w whereHelperbool) EQ(x bool) qm.QueryMod

func (whereHelperbool) GT

func (w whereHelperbool) GT(x bool) qm.QueryMod

func (whereHelperbool) GTE

func (w whereHelperbool) GTE(x bool) qm.QueryMod

func (whereHelperbool) LT

func (w whereHelperbool) LT(x bool) qm.QueryMod

func (whereHelperbool) LTE

func (w whereHelperbool) LTE(x bool) qm.QueryMod

func (whereHelperbool) NEQ

func (w whereHelperbool) NEQ(x bool) qm.QueryMod

type whereHelperint

type whereHelperint struct{ field string }

func (whereHelperint) EQ

func (w whereHelperint) EQ(x int) qm.QueryMod

func (whereHelperint) GT

func (w whereHelperint) GT(x int) qm.QueryMod

func (whereHelperint) GTE

func (w whereHelperint) GTE(x int) qm.QueryMod

func (whereHelperint) IN

func (w whereHelperint) IN(slice []int) qm.QueryMod

func (whereHelperint) LT

func (w whereHelperint) LT(x int) qm.QueryMod

func (whereHelperint) LTE

func (w whereHelperint) LTE(x int) qm.QueryMod

func (whereHelperint) NEQ

func (w whereHelperint) NEQ(x int) qm.QueryMod

func (whereHelperint) NIN

func (w whereHelperint) NIN(slice []int) qm.QueryMod

type whereHelpernull_Bool

type whereHelpernull_Bool struct{ field string }

func (whereHelpernull_Bool) EQ

func (w whereHelpernull_Bool) EQ(x null.Bool) qm.QueryMod

func (whereHelpernull_Bool) GT

func (w whereHelpernull_Bool) GT(x null.Bool) qm.QueryMod

func (whereHelpernull_Bool) GTE

func (w whereHelpernull_Bool) GTE(x null.Bool) qm.QueryMod

func (whereHelpernull_Bool) IsNotNull

func (w whereHelpernull_Bool) IsNotNull() qm.QueryMod

func (whereHelpernull_Bool) IsNull

func (w whereHelpernull_Bool) IsNull() qm.QueryMod

func (whereHelpernull_Bool) LT

func (w whereHelpernull_Bool) LT(x null.Bool) qm.QueryMod

func (whereHelpernull_Bool) LTE

func (w whereHelpernull_Bool) LTE(x null.Bool) qm.QueryMod

func (whereHelpernull_Bool) NEQ

func (w whereHelpernull_Bool) NEQ(x null.Bool) qm.QueryMod

type whereHelpernull_Int

type whereHelpernull_Int struct{ field string }

func (whereHelpernull_Int) EQ

func (w whereHelpernull_Int) EQ(x null.Int) qm.QueryMod

func (whereHelpernull_Int) GT

func (w whereHelpernull_Int) GT(x null.Int) qm.QueryMod

func (whereHelpernull_Int) GTE

func (w whereHelpernull_Int) GTE(x null.Int) qm.QueryMod

func (whereHelpernull_Int) IsNotNull

func (w whereHelpernull_Int) IsNotNull() qm.QueryMod

func (whereHelpernull_Int) IsNull

func (w whereHelpernull_Int) IsNull() qm.QueryMod

func (whereHelpernull_Int) LT

func (w whereHelpernull_Int) LT(x null.Int) qm.QueryMod

func (whereHelpernull_Int) LTE

func (w whereHelpernull_Int) LTE(x null.Int) qm.QueryMod

func (whereHelpernull_Int) NEQ

func (w whereHelpernull_Int) NEQ(x null.Int) qm.QueryMod

type whereHelpernull_String

type whereHelpernull_String struct{ field string }

func (whereHelpernull_String) EQ

func (w whereHelpernull_String) EQ(x null.String) qm.QueryMod

func (whereHelpernull_String) GT

func (w whereHelpernull_String) GT(x null.String) qm.QueryMod

func (whereHelpernull_String) GTE

func (w whereHelpernull_String) GTE(x null.String) qm.QueryMod

func (whereHelpernull_String) IsNotNull

func (w whereHelpernull_String) IsNotNull() qm.QueryMod

func (whereHelpernull_String) IsNull

func (w whereHelpernull_String) IsNull() qm.QueryMod

func (whereHelpernull_String) LT

func (w whereHelpernull_String) LT(x null.String) qm.QueryMod

func (whereHelpernull_String) LTE

func (w whereHelpernull_String) LTE(x null.String) qm.QueryMod

func (whereHelpernull_String) NEQ

func (w whereHelpernull_String) NEQ(x null.String) qm.QueryMod

type whereHelpernull_Time

type whereHelpernull_Time struct{ field string }

func (whereHelpernull_Time) EQ

func (w whereHelpernull_Time) EQ(x null.Time) qm.QueryMod

func (whereHelpernull_Time) GT

func (w whereHelpernull_Time) GT(x null.Time) qm.QueryMod

func (whereHelpernull_Time) GTE

func (w whereHelpernull_Time) GTE(x null.Time) qm.QueryMod

func (whereHelpernull_Time) IsNotNull

func (w whereHelpernull_Time) IsNotNull() qm.QueryMod

func (whereHelpernull_Time) IsNull

func (w whereHelpernull_Time) IsNull() qm.QueryMod

func (whereHelpernull_Time) LT

func (w whereHelpernull_Time) LT(x null.Time) qm.QueryMod

func (whereHelpernull_Time) LTE

func (w whereHelpernull_Time) LTE(x null.Time) qm.QueryMod

func (whereHelpernull_Time) NEQ

func (w whereHelpernull_Time) NEQ(x null.Time) qm.QueryMod

type whereHelperstring

type whereHelperstring struct{ field string }

func (whereHelperstring) EQ

func (w whereHelperstring) EQ(x string) qm.QueryMod

func (whereHelperstring) GT

func (w whereHelperstring) GT(x string) qm.QueryMod

func (whereHelperstring) GTE

func (w whereHelperstring) GTE(x string) qm.QueryMod

func (whereHelperstring) IN

func (w whereHelperstring) IN(slice []string) qm.QueryMod

func (whereHelperstring) LT

func (w whereHelperstring) LT(x string) qm.QueryMod

func (whereHelperstring) LTE

func (w whereHelperstring) LTE(x string) qm.QueryMod

func (whereHelperstring) NEQ

func (w whereHelperstring) NEQ(x string) qm.QueryMod

func (whereHelperstring) NIN

func (w whereHelperstring) NIN(slice []string) qm.QueryMod

type whereHelpertime_Time

type whereHelpertime_Time struct{ field string }

func (whereHelpertime_Time) EQ

func (w whereHelpertime_Time) EQ(x time.Time) qm.QueryMod

func (whereHelpertime_Time) GT

func (w whereHelpertime_Time) GT(x time.Time) qm.QueryMod

func (whereHelpertime_Time) GTE

func (w whereHelpertime_Time) GTE(x time.Time) qm.QueryMod

func (whereHelpertime_Time) LT

func (w whereHelpertime_Time) LT(x time.Time) qm.QueryMod

func (whereHelpertime_Time) LTE

func (w whereHelpertime_Time) LTE(x time.Time) qm.QueryMod

func (whereHelpertime_Time) NEQ

func (w whereHelpertime_Time) NEQ(x time.Time) qm.QueryMod

Generated by gomarkdoc